yandex-music-api-go/internal/ynison/helpers.go

// Package ynison provides a Ynison WebSocket client for player synchronization.
package ynison

import (
	"time"

	"gitea.mrixs.me/Mrixs/yandex-music-api-go/internal/ynison/proto"
)

// CreatePlayingStatus creates a playing status with the given parameters.
// The version timestamp is set to the current time.
func CreatePlayingStatus(progressMs, durationMs int64, paused bool, playbackSpeed float64, deviceID string) *proto.PlayingStatus {
	return &proto.PlayingStatus{
		ProgressMs:    progressMs,
		DurationMs:    durationMs,
		Paused:        paused,
		PlaybackSpeed: playbackSpeed,
		Version: &proto.UpdateVersion{
			DeviceId:    deviceID,
			Version:     1,
			TimestampMs: time.Now().UnixMilli(),
		},
	}
}

// CreatePlayable creates a playable entity with the given parameters.
func CreatePlayable(playableID, albumID, from, title, coverURL string, playableType proto.PlayablePlayableType) *proto.Playable {
	return &proto.Playable{
		PlayableId:       playableID,
		AlbumIdOptional:  albumID,
		PlayableType:     playableType,
		From:             from,
		Title:            title,
		CoverUrlOptional: coverURL,
	}
}

// CreateTrackPlayable creates a track playable with the given parameters.
func CreateTrackPlayable(playableID, albumID, from, title, coverURL string, trackSourceKey uint32, batchID string) *proto.Playable {
	return &proto.Playable{
		PlayableId:       playableID,
		AlbumIdOptional:  albumID,
		PlayableType:     proto.PlayablePlayableType_PLAYABLE_TYPE_TRACK,
		From:             from,
		Title:            title,
		CoverUrlOptional: coverURL,
		TrackInfo: &proto.TrackInfo{
			TrackSourceKey:  trackSourceKey,
			BatchIdOptional: batchID,
		},
	}
}

// CreateVideoClipPlayable creates a video clip playable with the given parameters.
func CreateVideoClipPlayable(playableID, from, title, coverURL string, recommendationType proto.VideoClipInfoRecommendationType) *proto.Playable {
	return &proto.Playable{
		PlayableId:       playableID,
		PlayableType:     proto.PlayablePlayableType_PLAYABLE_TYPE_VIDEO_CLIP,
		From:             from,
		Title:            title,
		CoverUrlOptional: coverURL,
		VideoClipInfo: &proto.VideoClipInfo{
			RecommendationType: recommendationType,
		},
	}
}

// CreatePlayerQueue creates a player queue with the given parameters.
func CreatePlayerQueue(entityID string, entityType proto.PlayerQueueEntityType, playables []*proto.Playable, currentIndex int32, deviceID string) *proto.PlayerQueue {
	return &proto.PlayerQueue{
		EntityId:             entityID,
		EntityType:           entityType,
		CurrentPlayableIndex: currentIndex,
		PlayableList:         playables,
		Options: &proto.PlayerStateOptions{
			RepeatMode: proto.PlayerStateOptionsRepeatMode_REPEAT_MODE_NONE,
		},
		Version: &proto.UpdateVersion{
			DeviceId:    deviceID,
			Version:     1,
			TimestampMs: time.Now().UnixMilli(),
		},
		EntityContext: proto.PlayerQueueEntityContext_ENTITY_CONTEXT_BASED_ON_ENTITY_BY_DEFAULT,
	}
}

// CreateWaveQueue creates a wave queue with the given parameters.
func CreateWaveQueue(recommended []*proto.Playable, liveIndex int32, sessionID string, deviceID string) *proto.PlayerQueueQueue {
	// Build track sources from playables
	var trackSources []*proto.PlayerQueueQueueWaveQueueEntityOptionsTrackSourceWithKey
	for i := range recommended {
		trackSources = append(trackSources, &proto.PlayerQueueQueueWaveQueueEntityOptionsTrackSourceWithKey{
			Key: uint32(i + 1),
			WaveSource: &proto.PlayerQueueQueueWaveQueueEntityOptionsWaveSource{
				SourceType: proto.WaveSourceSourceType_WAVE_SOURCE_ONLINE_BY_DEFAULT,
			},
		})
	}

	return &proto.PlayerQueueQueue{
		WaveQueue: &proto.PlayerQueueQueueWaveQueue{
			RecommendedPlayableList: recommended,
			LivePlayableIndex:       liveIndex,
			EntityOptions: &proto.PlayerQueueQueueWaveQueueEntityOptions{
				WaveEntityOptional: &proto.PlayerQueueQueueWaveQueueEntityOptionsWaveSession{
					SessionId: sessionID,
				},
				TrackSources: trackSources,
			},
			NavigationIdOptional:     "",
			PlaybackActionIdOptional: "",
		},
	}
}

// CreateGenerativeQueue creates a generative queue with the given ID.
func CreateGenerativeQueue(id string) *proto.PlayerQueueQueue {
	return &proto.PlayerQueueQueue{
		GenerativeQueue: &proto.PlayerQueueQueueGenerativeQueue{
			Id: id,
		},
	}
}

// CreateFMRadioQueue creates an FM radio queue
func CreateFMRadioQueue(id string) *proto.PlayerQueueQueue {
	return &proto.PlayerQueueQueue{
		FmRadioQueue: &proto.PlayerQueueQueueFmRadioQueue{
			Id: id,
		},
	}
}

// CreateVideoWaveQueue creates a video wave queue
func CreateVideoWaveQueue(id string) *proto.PlayerQueueQueue {
	return &proto.PlayerQueueQueue{
		VideoWaveQueue: &proto.PlayerQueueQueueVideoWaveQueue{
			Id: id,
		},
	}
}

// CreateLocalTracksQueue creates a local tracks queue
func CreateLocalTracksQueue() *proto.PlayerQueueQueue {
	return &proto.PlayerQueueQueue{
		LocalTracksQueue: &proto.PlayerQueueQueueLocalTracksQueue{},
	}
}

// CreateDeviceInfo creates device info
func CreateDeviceInfo(deviceID, title string, deviceType proto.DeviceType, appName, appVersion string) *proto.DeviceInfo {
	return &proto.DeviceInfo{
		DeviceId:   deviceID,
		Title:      title,
		Type:       deviceType,
		AppName:    appName,
		AppVersion: appVersion,
	}
}

// CreateDeviceCapabilities creates device capabilities
func CreateDeviceCapabilities(canBePlayer, canBeRemote bool, volumeGranularity uint32) *proto.DeviceCapabilities {
	return &proto.DeviceCapabilities{
		CanBePlayer:           canBePlayer,
		CanBeRemoteController: canBeRemote,
		VolumeGranularity:     volumeGranularity,
	}
}

// CreateDeviceVolume creates device volume
func CreateDeviceVolume(volume float64, deviceID string) *proto.DeviceVolume {
	return &proto.DeviceVolume{
		Volume: volume,
		Version: &proto.UpdateVersion{
			DeviceId:    deviceID,
			Version:     1,
			TimestampMs: time.Now().UnixMilli(),
		},
	}
}

// CreateDevice creates a device
func CreateDevice(deviceID, title string, deviceType proto.DeviceType, appName, appVersion string, volume float64) *proto.Device {
	return &proto.Device{
		Info:         CreateDeviceInfo(deviceID, title, deviceType, appName, appVersion),
		Volume:       volume,
		Capabilities: CreateDeviceCapabilities(true, true, 100),
		Session: &proto.Session{
			Id: time.Now().UnixNano(),
		},
		IsOffline:  false,
		VolumeInfo: CreateDeviceVolume(volume, deviceID),
	}
}

// CreateUpdateFullState creates an UpdateFullState request
func CreateUpdateFullState(deviceID string, isActive bool, playerState *proto.PlayerState) *proto.UpdateFullState {
	return &proto.UpdateFullState{
		PlayerState:       playerState,
		IsCurrentlyActive: isActive,
		Device: &proto.UpdateDevice{
			Info:         CreateDeviceInfo(deviceID, "Go Ynison Client", proto.DeviceType_DEVICE_TYPE_WEB_DESKTOP, "YandexMusicGo", "1.0.0"),
			Volume:       0.5,
			Capabilities: CreateDeviceCapabilities(true, true, 100),
			VolumeInfo:   CreateDeviceVolume(0.5, deviceID),
		},
	}
}