oysteikt/mpvipc
oysteikt
/
mpvipc
1
0
Fork 0
Code Issues Pull Requests Actions Packages Releases Activity

Keeps the socket open for the entire lifetime of the Mpv struct. Now using channels to inform about new events (listen command). Added Readme

This commit is contained in:
Jonas Frei 2017-05-29 17:54:12 +02:00
parent e797bd871a
commit ea0e60097d
4 changed files with 134 additions and 171 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
Cargo.toml
View File

@ -1,6 +1,6 @@
[package]
name = "mpvipc"
version = "1.0.0"
version = "1.1.0"
authors = ["Jonas Frei <freijon@gmail.com>"]
description = "A small library which provides bindings to control existing mpv instances through sockets."
license = "GPL-3.0"

45
README.md Normal file
View File

@ -0,0 +1,45 @@
# mpvipc
A small library which provides bindings to control existing mpv instances through sockets.
To make use of this library, please make sure mpv is started with the following option:
`
$ mpv --input-ipc-server=/tmp/mpvsocket --idle ...
`
## Dependencies
- `mpv`
- `cargo` (makedep)
## Install
- [Cargo](https://crates.io/crates/mpvipc)
You can use this package with cargo.
## Example
Make sure mpv is started with the following option:
`
$ mpv --input-ipc-server=/tmp/mpvsocket --idle
`
Here is a small code example which connects to the socket /tmp/mpvsocket and toggles playback.
```
use mpvipc::*;
use std::sync::mpsc::channel;
fn main() {
let mpv = Mpv::connect("/tmp/mpvsocket").unwrap();
let paused: bool = mpv.get_property("pause").unwrap();
mpv.set_property("pause", !paused).expect("Error pausing");
}
```
For a more extensive example and proof of concept, see project [mpvc](https://github.com/freijon/mpvc-rs).
## Bugs / Ideas
Check out the [Issue Tracker](https://github.com/freijon/mpvipc/issues)

80
src/ipc.rs
View File

@ -4,9 +4,8 @@ use std::error::Error;
use std::io::BufReader;
use std::io::prelude::*;
use std::iter::Iterator;
use std::os::unix::net::UnixStream;
use std::net::Shutdown;
use std::sync::mpsc::Sender;
use super::Mpv;
#[derive(Debug)]
pub struct PlaylistEntry {
@ -209,18 +208,18 @@ impl TypeHandler for Vec<PlaylistEntry> {
}
}
pub fn get_mpv_property<T: TypeHandler>(socket: &str, property: &str) -> Result<T, String> {
pub fn get_mpv_property<T: TypeHandler>(instance: &Mpv, property: &str) -> Result<T, String> {
let ipc_string = format!("{{ \"command\": [\"get_property\",\"{}\"] }}\n", property);
match serde_json::from_str::<Value>(&send_command_sync(socket, &ipc_string)) {
match serde_json::from_str::<Value>(&send_command_sync(instance, &ipc_string)) {
Ok(val) => T::get_value(val),
Err(why) => Err(format!("Error while getting property: {}", why)),
}
}
pub fn get_mpv_property_string(socket: &str, property: &str) -> Result<String, String> {
pub fn get_mpv_property_string(instance: &Mpv, property: &str) -> Result<String, String> {
let ipc_string = format!("{{ \"command\": [\"get_property\",\"{}\"] }}\n", property);
match serde_json::from_str::<Value>(&send_command_sync(socket, &ipc_string)) {
match serde_json::from_str::<Value>(&send_command_sync(instance, &ipc_string)) {
Ok(val) => {
if let Value::Object(map) = val {
if let Value::String(ref error) = map["error"] {
@ -247,20 +246,20 @@ pub fn get_mpv_property_string(socket: &str, property: &str) -> Result<String, S
}
}
pub fn set_mpv_property<T: TypeHandler>(socket: &str,
pub fn set_mpv_property<T: TypeHandler>(instance: &Mpv,
property: &str,
value: T)
-> Result<(), String> {
let ipc_string = format!("{{ \"command\": [\"set_property\", \"{}\", {}] }}\n",
property,
value.as_string());
match serde_json::from_str::<Value>(&send_command_sync(socket, &ipc_string)) {
match serde_json::from_str::<Value>(&send_command_sync(instance, &ipc_string)) {
Ok(_) => Ok(()),
Err(why) => Err(why.description().to_string()),
}
}
pub fn run_mpv_command(socket: &str, command: &str, args: &Vec<&str>) -> Result<(), String> {
pub fn run_mpv_command(instance: &Mpv, command: &str, args: &Vec<&str>) -> Result<(), String> {
let mut ipc_string = format!("{{ \"command\": [\"{}\"", command);
if args.len() > 0 {
for arg in args.iter() {
@ -269,7 +268,7 @@ pub fn run_mpv_command(socket: &str, command: &str, args: &Vec<&str>) -> Result<
}
ipc_string.push_str("] }\n");
ipc_string = ipc_string;
match serde_json::from_str::<Value>(&send_command_sync(socket, &ipc_string)) {
match serde_json::from_str::<Value>(&send_command_sync(instance, &ipc_string)) {
Ok(feedback) => {
if let Value::String(ref error) = feedback["error"] {
if error == "success" {
@ -278,6 +277,7 @@ pub fn run_mpv_command(socket: &str, command: &str, args: &Vec<&str>) -> Result<
Err(error.to_string())
}
} else {
//Ok(())
Err("Error: Unexpected result received".to_string())
}
}
@ -285,11 +285,11 @@ pub fn run_mpv_command(socket: &str, command: &str, args: &Vec<&str>) -> Result<
}
}
pub fn observe_mpv_property(socket: &str, id: &usize, property: &str) -> Result<(), String> {
pub fn observe_mpv_property(instance: &Mpv, id: &usize, property: &str) -> Result<(), String> {
let ipc_string = format!("{{ \"command\": [\"observe_property\", {}, \"{}\"] }}\n",
id,
property);
match serde_json::from_str::<Value>(&send_command_sync(socket, &ipc_string)) {
match serde_json::from_str::<Value>(&send_command_sync(instance, &ipc_string)) {
Ok(feedback) => {
if let Value::String(ref error) = feedback["error"] {
if error == "success" {
@ -314,47 +314,35 @@ pub fn observe_mpv_property(socket: &str, id: &usize, property: &str) -> Result<
/// ```
/// listen("/tmp/mpvsocket");
/// ```
pub fn listen(socket: &str, tx: &Sender<String>) {
match UnixStream::connect(socket) {
Ok(stream) => {
let mut response = String::new();
let mut reader = BufReader::new(&stream);
reader.read_line(&mut response).unwrap();
match serde_json::from_str::<Value>(&response) {
Ok(e) => {
if let Value::String(ref name) = e["event"] {
tx.send(name.to_string()).unwrap();
}
}
Err(why) => panic!("{}", why.description().to_string()),
pub fn listen(instance: &Mpv, tx: &Sender<String>) {
let mut response = String::new();
let mut reader = BufReader::new(instance);
reader.read_line(&mut response).unwrap();
match serde_json::from_str::<Value>(&response) {
Ok(e) => {
if let Value::String(ref name) = e["event"] {
tx.send(name.to_string()).unwrap();
}
response.clear();
stream
.shutdown(Shutdown::Both)
.expect("shutdown function failed");
}
Err(why) => panic!("Error: Could not connect to socket: {}", why.description()),
Err(why) => panic!("{}", why.description().to_string()),
}
response.clear();
}
fn send_command_sync(socket: &str, command: &str) -> String {
match UnixStream::connect(socket) {
Ok(mut stream) => {
match stream.write_all(command.as_bytes()) {
Err(why) => panic!("Error: Could not write to socket: {}", why.description()),
Ok(_) => {
let mut response = String::new();
{
let mut reader = BufReader::new(&stream);
reader.read_line(&mut response).unwrap();
}
stream
.shutdown(Shutdown::Both)
.expect("shutdown function failed");
response
fn send_command_sync(instance: &Mpv, command: &str) -> String {
let mut stream = instance;
match stream.write_all(command.as_bytes()) {
Err(why) => panic!("Error: Could not write to socket: {}", why.description()),
Ok(_) => {
let mut response = String::new();
{
let mut reader = BufReader::new(stream);
while !response.contains("\"error\":") {
response.clear();
reader.read_line(&mut response).unwrap();
}
}
response
}
Err(why) => panic!("Error: Could not connect to socket: {}", why.description()),
}
}

178
src/lib.rs
View File

@ -5,10 +5,10 @@ pub mod ipc;
use ipc::*;
use std::collections::HashMap;
use std::os::unix::net::UnixStream;
use std::sync::mpsc::Sender;
pub type Socket = String;
pub type Mpv = UnixStream;
pub enum NumberChangeOptions {
Absolute,
@ -35,159 +35,88 @@ pub enum Switch {
Toggle,
}
pub struct Playlist {
pub socket: Socket,
pub entries: Vec<PlaylistEntry>,
pub struct Playlist(pub Vec<PlaylistEntry>);
pub trait MpvConnector {
fn connect(socket: &str) -> Result<Mpv, String>;
}
impl MpvConnector for Mpv {
fn connect(socket: &str) -> Result<Mpv, String> {
match UnixStream::connect(socket) {
Ok(stream) => Ok(stream),
Err(msg) => Err(msg.to_string()),
}
}
}
pub trait GetPropertyTypeHandler: Sized {
fn get_property_generic(socket: &str, property: &str) -> Result<Self, String>;
fn get_property_generic(instance: &Mpv, property: &str) -> Result<Self, String>;
}
impl GetPropertyTypeHandler for bool {
fn get_property_generic(socket: &str, property: &str) -> Result<bool, String> {
get_mpv_property::<bool>(socket, property)
fn get_property_generic(instance: &Mpv, property: &str) -> Result<bool, String> {
get_mpv_property::<bool>(instance, property)
}
}
impl GetPropertyTypeHandler for String {
fn get_property_generic(socket: &str, property: &str) -> Result<String, String> {
get_mpv_property::<String>(socket, property)
fn get_property_generic(instance: &Mpv, property: &str) -> Result<String, String> {
get_mpv_property::<String>(instance, property)
}
}
impl GetPropertyTypeHandler for f64 {
fn get_property_generic(socket: &str, property: &str) -> Result<f64, String> {
get_mpv_property::<f64>(socket, property)
fn get_property_generic(instance: &Mpv, property: &str) -> Result<f64, String> {
get_mpv_property::<f64>(instance, property)
}
}
impl GetPropertyTypeHandler for usize {
fn get_property_generic(socket: &str, property: &str) -> Result<usize, String> {
get_mpv_property::<usize>(socket, property)
fn get_property_generic(instance: &Mpv, property: &str) -> Result<usize, String> {
get_mpv_property::<usize>(instance, property)
}
}
impl GetPropertyTypeHandler for Vec<PlaylistEntry> {
fn get_property_generic(socket: &str, property: &str) -> Result<Vec<PlaylistEntry>, String> {
get_mpv_property::<Vec<PlaylistEntry>>(socket, property)
fn get_property_generic(instance: &Mpv, property: &str) -> Result<Vec<PlaylistEntry>, String> {
get_mpv_property::<Vec<PlaylistEntry>>(instance, property)
}
}
impl GetPropertyTypeHandler for HashMap<String, String> {
fn get_property_generic(socket: &str,
fn get_property_generic(instance: &Mpv,
property: &str)
-> Result<HashMap<String, String>, String> {
get_mpv_property::<HashMap<String, String>>(socket, property)
get_mpv_property::<HashMap<String, String>>(instance, property)
}
}
pub trait SetPropertyTypeHandler<T> {
fn set_property_generic(socket: &str, property: &str, value: T) -> Result<(), String>;
fn set_property_generic(instance: &Mpv, property: &str, value: T) -> Result<(), String>;
}
impl SetPropertyTypeHandler<bool> for bool {
fn set_property_generic(socket: &str, property: &str, value: bool) -> Result<(), String> {
set_mpv_property::<bool>(socket, property, value)
fn set_property_generic(instance: &Mpv, property: &str, value: bool) -> Result<(), String> {
set_mpv_property::<bool>(instance, property, value)
}
}
impl SetPropertyTypeHandler<String> for String {
fn set_property_generic(socket: &str, property: &str, value: String) -> Result<(), String> {
set_mpv_property::<String>(socket, property, value)
fn set_property_generic(instance: &Mpv, property: &str, value: String) -> Result<(), String> {
set_mpv_property::<String>(instance, property, value)
}
}
impl SetPropertyTypeHandler<f64> for f64 {
fn set_property_generic(socket: &str, property: &str, value: f64) -> Result<(), String> {
set_mpv_property::<f64>(socket, property, value)
fn set_property_generic(instance: &Mpv, property: &str, value: f64) -> Result<(), String> {
set_mpv_property::<f64>(instance, property, value)
}
}
impl SetPropertyTypeHandler<usize> for usize {
fn set_property_generic(socket: &str, property: &str, value: usize) -> Result<(), String> {
set_mpv_property::<usize>(socket, property, value)
}
}
pub trait PlaylistHandler {
fn get_from(socket: Socket) -> Result<Playlist, String>;
fn shuffle(&mut self) -> &mut Playlist;
fn remove_id(&mut self, id: usize) -> &mut Playlist;
fn move_entry(&mut self, from: usize, to: usize) -> &mut Playlist;
fn current_id(&self) -> Option<usize>;
}
impl PlaylistHandler for Playlist {
fn get_from(socket: Socket) -> Result<Playlist, String> {
match get_mpv_property(&socket, "playlist") {
Ok(playlist) => {
Ok(Playlist {
socket: socket,
entries: playlist,
})
}
Err(why) => Err(why),
}
}
fn shuffle(&mut self) -> &mut Playlist {
if let Err(error_msg) = run_mpv_command(&self.socket, "playlist-shuffle", &vec![]) {
panic!("Error: {}", error_msg);
}
if let Ok(mut playlist_entries) =
get_mpv_property::<Vec<PlaylistEntry>>(&self.socket, "playlist") {
if self.entries.len() == playlist_entries.len() {
for (i, entry) in playlist_entries.drain(0..).enumerate() {
self.entries[i] = entry;
}
}
}
self
}
fn remove_id(&mut self, id: usize) -> &mut Playlist {
self.entries.remove(id);
if let Err(error_msg) = run_mpv_command(&self.socket,
"playlist-remove",
&vec![&id.to_string()]) {
panic!("Error: {}", error_msg);
}
self
}
fn move_entry(&mut self, from: usize, to: usize) -> &mut Playlist {
if from != to {
if let Err(error_msg) = run_mpv_command(&self.socket,
"playlist-move",
&vec![&from.to_string(), &to.to_string()]) {
panic!("Error: {}", error_msg);
}
if from < to {
self.entries[from].id = to - 1;
self.entries[to].id = to - 2;
for i in from..to - 2 {
self.entries[i + 1].id = i;
}
self.entries.sort_by_key(|entry| entry.id);
} else if from > to {
self.entries[from].id = to;
for i in to..from - 1 {
self.entries[i].id = i + 1;
}
self.entries.sort_by_key(|entry| entry.id);
}
}
self
}
fn current_id(&self) -> Option<usize> {
for entry in self.entries.iter() {
if entry.current {
return Some(entry.id);
}
}
None
fn set_property_generic(instance: &Mpv, property: &str, value: usize) -> Result<(), String> {
set_mpv_property::<usize>(instance, property, value)
}
}
@ -204,6 +133,8 @@ pub trait Commands {
/// - bool
/// - HashMap<String, String> (e.g. for the 'metadata' property)
/// - Vec<PlaylistEntry> (for the 'playlist' property)
/// - usize
/// - f64
///
/// ##Input arguments
///
@ -212,7 +143,7 @@ pub trait Commands {
///
/// #Example
/// ```
/// let mpv: Socket = String::from(matches.value_of("socket").unwrap());
/// let mpv = Mpv::connect("/tmp/mpvsocket").unwrap();
/// let paused: bool = mpv.get_property("pause").unwrap();
/// let title: String = mpv.get_property("media-title").unwrap();
/// ```
@ -231,7 +162,7 @@ pub trait Commands {
/// #Example
///
/// ```
/// let mpv: Socket = String::from(matches.value_of("socket").unwrap());
/// let mpv = Mpv::connect("/tmp/mpvsocket").unwrap();
/// let title = mpv.get_property_string("media-title").unwrap();
/// ```
fn get_property_string(&self, property: &str) -> Result<String, String>;
@ -256,7 +187,7 @@ pub trait Commands {
///
/// #Example
/// ```
/// let mpv: Socket = String::from(matches.value_of("socket").unwrap());
/// let mpv = Mpv::connect("/tmp/mpvsocket").unwrap();
///
/// //Run command 'playlist-shuffle' which takes no arguments
/// mpv.run_command("playlist-shuffle", &vec![]);
@ -287,7 +218,7 @@ pub trait Commands {
///
/// #Example
/// ```
/// let mpv: Socket = String::from(matches.value_of("socket").unwrap());
/// let mpv = Mpv::connect("/tmp/mpvsocket").unwrap();
/// mpv.set_property("pause", true);
/// ```
fn set_property<T: SetPropertyTypeHandler<T>>(&self,
@ -300,7 +231,7 @@ pub trait Commands {
fn toggle(&self) -> Result<(), String>;
}
impl Commands for Socket {
impl Commands for Mpv {
fn get_metadata(&self) -> Result<HashMap<String, String>, String> {
match get_mpv_property(self, "metadata") {
Ok(map) => Ok(map),
@ -309,7 +240,10 @@ impl Commands for Socket {
}
fn get_playlist(&self) -> Result<Playlist, String> {
Playlist::get_from(self.to_string())
match get_mpv_property::<Vec<PlaylistEntry>>(self, "playlist") {
Ok(entries) => Ok(Playlist(entries)),
Err(msg) => Err(msg),
}
}
fn get_property<T: GetPropertyTypeHandler>(&self, property: &str) -> Result<T, String> {
@ -379,17 +313,13 @@ impl Commands for Socket {
}
fn playlist_play_next(&self, id: usize) -> Result<(), String> {
match Playlist::get_from(self.to_string()) {
Ok(playlist) => {
if let Some(current_id) = playlist.current_id() {
run_mpv_command(self,
"playlist-move",
&vec![&id.to_string(), &(current_id + 1).to_string()])
} else {
Err("There is no file playing at the moment.".to_string())
}
match get_mpv_property::<usize>(self, "playlist-pos") {
Ok(current_id) => {
run_mpv_command(self,
"playlist-move",
&vec![&id.to_string(), &(current_id + 1).to_string()])
}
Err(why) => Err(why),
Err(msg) => Err(msg),
}
}