feat: Generalize TrackId into SpotifyId

This allows to parse both tracks and episodes and avoid crashing when we get an unknown Spotify uri.

Author: devgianlu

audio/provider.go

@@ -89,13 +89,15 @@ func (p *KeyProvider) recvLoop() {
 
 			reqs[reqSeq] = req
 
+			// FIXME: this might not always be a track
+			uri := librespot.SpotifyIdFromGid(librespot.SpotifyIdTypeTrack, req.gid).Uri()
 			if err := p.ap.Send(ap.PacketTypeRequestKey, buf.Bytes()); err != nil {
 				delete(reqs, reqSeq)
 				req.resp <- keyResponse{err: fmt.Errorf("failed sending key request for file %s, track: %s: %w",
-					hex.EncodeToString(req.fileId), librespot.TrackId(req.gid).Uri(), err)}
+					hex.EncodeToString(req.fileId), uri, err)}
 			}
 
-			log.Debugf("requested aes key for file %s, track: %s", hex.EncodeToString(req.fileId), librespot.TrackId(req.gid).Uri())
+			log.Debugf("requested aes key for file %s, track: %s", hex.EncodeToString(req.fileId), uri)
 		}
 	}
 }

cmd/daemon/api_server.go

@@ -112,7 +112,8 @@ func NewApiResponseStatusTrack(track *metadatapb.Track, prodInfo *ProductInfo, p
 	}
 
 	return &ApiResponseStatusTrack{
-		Uri:           librespot.TrackId(track.Gid).Uri(),
+		// FIXME: this might not always be a track
+		Uri:           librespot.SpotifyIdFromGid(librespot.SpotifyIdTypeTrack, track.Gid).Uri(),
 		Name:          *track.Name,
 		ArtistNames:   artists,
 		AlbumName:     *track.Album.Name,

cmd/daemon/controls.go

@@ -114,10 +114,14 @@ func (s *Session) loadCurrentTrack(paused bool) error {
 		s.stream = nil
 	}
 
-	trackId := librespot.TrackIdFromUri(s.state.player.Track.Uri)
-	trackPosition := s.state.trackPosition()
+	spotId := librespot.SpotifyIdFromUri(s.state.player.Track.Uri)
+	println("spot", spotId.Type(), spotId.Uri())
+	if spotId.Type() != librespot.SpotifyIdTypeTrack {
+		return fmt.Errorf("unsupported spotify type: %s", spotId.Type())
+	}
 
-	log.Debugf("loading track %s (paused: %t, position: %dms)", trackId.Uri(), paused, trackPosition)
+	trackPosition := s.state.trackPosition()
+	log.Debugf("loading %s %s (paused: %t, position: %dms)", spotId.Type(), spotId.Uri(), paused, trackPosition)
 
 	s.state.player.IsPlaying = true
 	s.state.player.IsBuffering = true
@@ -127,17 +131,17 @@ func (s *Session) loadCurrentTrack(paused bool) error {
 	s.app.server.Emit(&ApiEvent{
 		Type: ApiEventTypeWillPlay,
 		Data: ApiEventDataWillPlay{
-			Uri:        trackId.Uri(),
+			Uri:        spotId.Uri(),
 			PlayOrigin: s.state.playOrigin(),
 		},
 	})
 
-	stream, err := s.player.NewStream(trackId, s.app.cfg.Bitrate, trackPosition, paused)
+	stream, err := s.player.NewStream(spotId, s.app.cfg.Bitrate, trackPosition, paused)
 	if err != nil {
 		return fmt.Errorf("failed creating stream: %w", err)
 	}
 
-	log.Infof("loaded track \"%s\" (uri: %s, paused: %t, position: %dms, duration: %dms)", *stream.Track.Name, trackId.Uri(), paused, trackPosition, *stream.Track.Duration)
+	log.Infof("loaded track \"%s\" (uri: %s, paused: %t, position: %dms, duration: %dms)", *stream.Track.Name, spotId.Uri(), paused, trackPosition, *stream.Track.Duration)
 
 	s.state.player.Duration = int64(*stream.Track.Duration)
 	s.state.player.IsPlaying = true

cmd/daemon/session.go

@@ -171,7 +171,7 @@ func (s *Session) handlePlayerCommand(req dealer.RequestPayload) error {
 				return true
 			} else if len(track.Uri) > 0 && track.Uri == currentTrack.Uri {
 				return true
-			} else if len(track.Gid) > 0 && librespot.TrackId(track.Gid).Uri() == currentTrack.Uri {
+			} else if len(track.Gid) > 0 && librespot.SpotifyIdFromGid(librespot.SpotifyIdTypeTrack, track.Gid).Uri() == currentTrack.Uri /* FIXME: this might not always be a track */ {
 				return true
 			} else {
 				return false

ids.go

@@ -14,7 +14,8 @@ var UriRegexp = regexp.MustCompile("^spotify:([a-z]+):([0-9a-zA-Z]{21,22})$")
 func ContextTrackToProvidedTrack(track *connectpb.ContextTrack) *connectpb.ProvidedTrack {
 	var uri string
 	if len(track.Gid) > 0 {
-		uri = TrackId(track.Gid).Uri()
+		// FIXME: this might not always be a track
+		uri = SpotifyIdFromGid(SpotifyIdTypeTrack, track.Gid).Uri()
 	} else if len(track.Uri) > 0 {
 		uri = track.Uri
 	} else {
@@ -34,27 +35,51 @@ func ContextTrackToProvidedTrack(track *connectpb.ContextTrack) *connectpb.Provi
 	}
 }
 
-type TrackId []byte
+type SpotifyIdType string
 
-func (id TrackId) Hex() string {
-	return hex.EncodeToString(id)
+const (
+	SpotifyIdTypeTrack   SpotifyIdType = "track"
+	SpotifyIdTypeEpisode SpotifyIdType = "episode"
+)
+
+type SpotifyId struct {
+	typ SpotifyIdType
+	id  []byte
+}
+
+func (id SpotifyId) Type() SpotifyIdType {
+	return id.typ
+}
+
+func (id SpotifyId) Id() []byte {
+	return id.id
 }
 
-func (id TrackId) Base62() string {
-	s := new(big.Int).SetBytes(id).Text(62)
+func (id SpotifyId) Hex() string {
+	return hex.EncodeToString(id.id)
+}
+
+func (id SpotifyId) Base62() string {
+	s := new(big.Int).SetBytes(id.id).Text(62)
 	return strings.Repeat("0", 22-len(s)) + s
 }
 
-func (id TrackId) Uri() string {
-	return fmt.Sprintf("spotify:track:%s", id.Base62())
+func (id SpotifyId) Uri() string {
+	return fmt.Sprintf("spotify:%s:%s", id.Type(), id.Base62())
+}
+
+func SpotifyIdFromGid(typ SpotifyIdType, id []byte) SpotifyId {
+	if len(id) != 16 {
+		panic(fmt.Sprintf("invalid gid: %s", hex.EncodeToString(id)))
+	}
+
+	return SpotifyId{typ, id}
 }
 
-func TrackIdFromUri(uri string) TrackId {
+func SpotifyIdFromUri(uri string) SpotifyId {
 	matches := UriRegexp.FindStringSubmatch(uri)
 	if len(matches) == 0 {
 		panic(fmt.Sprintf("invalid uri: %s", uri))
-	} else if matches[1] != "track" {
-		panic(fmt.Sprintf("invalid uri type for track: %s", matches[1]))
 	}
 
 	var i big.Int
@@ -63,5 +88,5 @@ func TrackIdFromUri(uri string) TrackId {
 		panic("failed decoding base62 track uri")
 	}
 
-	return i.FillBytes(make([]byte, 16))
+	return SpotifyId{SpotifyIdType(matches[1]), i.FillBytes(make([]byte, 16))}
 }

player/player.go

@@ -221,7 +221,7 @@ func (p *Player) SetVolume(val uint32) {
 
 const DisableCheckTrackRestricted = true
 
-func (p *Player) NewStream(tid librespot.TrackId, bitrate int, trackPosition int64, paused bool) (*Stream, error) {
+func (p *Player) NewStream(tid librespot.SpotifyId, bitrate int, trackPosition int64, paused bool) (*Stream, error) {
 	trackMeta, err := p.sp.MetadataForTrack(tid)
 	if err != nil {
 		return nil, fmt.Errorf("failed getting track metadata: %w", err)
@@ -248,7 +248,7 @@ func (p *Player) NewStream(tid librespot.TrackId, bitrate int, trackPosition int
 
 	log.Debugf("selected format %s for %s", file.Format.String(), tid.Uri())
 
-	audioKey, err := p.audioKey.Request(tid, file.FileId)
+	audioKey, err := p.audioKey.Request(tid.Id(), file.FileId)
 	if err != nil {
 		return nil, fmt.Errorf("failed retrieving audio key: %w", err)
 	}

spclient/spclient.go

@@ -180,7 +180,11 @@ func (c *Spclient) ResolveStorageInteractive(fileId []byte, prefetch bool) (*sto
 	return &protoResp, nil
 }
 
-func (c *Spclient) MetadataForTrack(track librespot.TrackId) (*metadatapb.Track, error) {
+func (c *Spclient) MetadataForTrack(track librespot.SpotifyId) (*metadatapb.Track, error) {
+	if track.Type() != librespot.SpotifyIdTypeTrack {
+		panic(fmt.Sprintf("invalid type: %s", track.Type()))
+	}
+
 	resp, err := c.request("GET", fmt.Sprintf("/metadata/4/track/%s", track.Hex()), nil, nil, nil)
 	if err != nil {
 		return nil, err