Building a Chromecast Plugin for my Rust Music Player Project
Tags: rust, chromecast, cli, github
Published: 2023-02-19 05:50:26

Recently, I built a Chromecast plugin for my Rust-based [music player project](https://github.com/tsirysndr/music-player) on Github. In this blog post, I will walk you through the steps I took to build the plugin, and highlight some of the key features and design decisions that went into its development.

## Overview

My music player project was originally built as a command-line tool, but I wanted to extend its functionality to support casting audio to Chromecast devices. To achieve this, I built a new [Rust module ](https://github.com/tsirysndr/music-player/blob/master/addons/src/chromecast.rs)called "Chromecast", which defines a struct that implements the "Addon" and "Player" traits in my player's architecture.

```rust
pub trait Addon {
    fn name(&self) -> &str;
    fn version(&self) -> &str;
    fn author(&self) -> &str;
    fn description(&self) -> &str;
    fn enabled(&self) -> bool;
    fn set_enabled(&mut self, enabled: bool);
}

#[async_trait]
pub trait Player {
    async fn play(&mut self) -> Result<(), Error>;
    async fn pause(&mut self) -> Result<(), Error>;
    async fn stop(&mut self) -> Result<(), Error>;
    async fn next(&mut self) -> Result<(), Error>;
    async fn previous(&mut self) -> Result<(), Error>;
    async fn seek(&mut self, position: u32) -> Result<(), Error>;
    async fn load_tracks(
        &mut self,
        tracks: Vec<Track>,
        start_index: Option<i32>,
    ) -> Result<(), Error>;
    async fn play_next(&mut self, track: Track) -> Result<(), Error>;
    async fn load(&mut self, track: Track) -> Result<(), Error>;
    async fn get_current_playback(&mut self) -> Result<Playback, Error>;
    async fn get_current_tracklist(&mut self) -> Result<(Vec<Track>, Vec<Track>), Error>;
    async fn play_track_at(&mut self, position: u32) -> Result<(), Error>;
    async fn remove_track_at(&mut self, position: u32) -> Result<(), Error>;
    fn device_type(&self) -> String;
    fn disconnect(&mut self) -> Result<(), Error>;
}
```

## Design and Implementation

The Chromecast struct contains several fields, including the device name, version, author, description, host and port, client connection, transport ID, session ID, current playback status, and a CastPlayer instance for sending media commands to the Chromecast device.

One of the most important methods in the Chromecast struct is "connect()", which connects to the Chromecast device and launches the Music Player App. This method uses the "CastDevice" and "CastDeviceApp" structs from the Rust crate ["chromecast"](https://github.com/tsirysndr/rust-cast) to establish a connection and retrieve the transport and session IDs required for media playback.

The Chromecast struct also implements the "Player" trait, which defines methods for media playback, such as "play()", "pause()", "stop()", "seek()", and "set_volume()". These methods use the "CastPlayer" instance to send media commands to the Chromecast device over the established connection.

```rust
#[async_trait]
impl<'a> Player for Chromecast<'a> {
    async fn play(&mut self) -> Result<(), Error> {
        self.cmd_tx
            .as_ref()
            .unwrap()
            .send(CastPlayerCommand::Play)
            .unwrap();
        Ok(())
    }

    async fn pause(&mut self) -> Result<(), Error> {
        self.cmd_tx
            .as_ref()
            .unwrap()
            .send(CastPlayerCommand::Pause)
            .unwrap();
        Ok(())
    }

    async fn stop(&mut self) -> Result<(), Error> {
        self.cmd_tx
            .as_ref()
            .unwrap()
            .send(CastPlayerCommand::Stop)
            .unwrap();
        Ok(())
    }

    async fn next(&mut self) -> Result<(), Error> {
        self.cmd_tx
            .as_ref()
            .unwrap()
            .send(CastPlayerCommand::Next)
            .unwrap();
        Ok(())
    }

    async fn previous(&mut self) -> Result<(), Error> {
        self.cmd_tx
            .as_ref()
            .unwrap()
            .send(CastPlayerCommand::Previous)
            .unwrap();
        Ok(())
    }
 // ...
}
```

## Conslusion

In conclusion, I have developed a Rust-based Chromecast plugin for my music player project on GitHub. The plugin allows users to cast their music playback to a Chromecast device with ease. I hope that this plugin will help enhance the user experience for our music player users.

This project is open source, and we welcome contributions from the community to help improve the plugin. If you are interested in contributing to the project, please feel free to check out the project's [GitHub page](https://github.com/tsirysndr/music-player) and submit a pull request or open an issue. We appreciate any feedback and contributions that can help us make the plugin better.