commit f595113276de94b652ab62f4d379d33c4d0a42b1 Author: Nolan Darilek Date: Fri Jan 12 11:28:39 2018 -0600 Initial commit. diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..4308d82 --- /dev/null +++ b/.gitignore @@ -0,0 +1,3 @@ +target/ +**/*.rs.bk +Cargo.lock diff --git a/.gitlab-ci.yml b/.gitlab-ci.yml new file mode 100644 index 0000000..6054709 --- /dev/null +++ b/.gitlab-ci.yml @@ -0,0 +1,24 @@ +image: rust + +stages: + - test + - publish + +before_script: + - apt-get update + - apt-get install -y libclang-3.9-dev libspeechd-dev + - export CPATH=/usr/lib/llvm-3.9/lib/clang/3.9.1/include/ + +test: + stage: test + script: + - cargo test + +publish: + stage: publish + script: + - cargo login $CARGO_TOKEN + - cargo package + - cargo publish + only: + - tags diff --git a/Cargo.toml b/Cargo.toml new file mode 100644 index 0000000..13154be --- /dev/null +++ b/Cargo.toml @@ -0,0 +1,7 @@ +[package] +name = "speech-dispatcher" +version = "0.1.0" +authors = ["Nolan Darilek "] + +[dependencies] +speech-dispatcher-sys = "0.2" diff --git a/examples/hello_world.rs b/examples/hello_world.rs new file mode 100644 index 0000000..8285957 --- /dev/null +++ b/examples/hello_world.rs @@ -0,0 +1,17 @@ +extern crate speech_dispatcher; + +use speech_dispatcher::*; + +fn main() { + let connection = speech_dispatcher::Connection::open("hello_world".to_string(), "hello_world".to_string(), "hello_world".to_string(), Mode::Single); + connection.say(Priority::Important, format!("Hello, world at rate {}.", connection.get_voice_rate())); + connection.set_voice_rate(100); + connection.say(Priority::Important, "This is faster.".to_string()); + connection.set_voice_rate(0); + connection.set_spelling(true); + connection.say(Priority::Important, "This is spelled.".to_string()); + connection.set_spelling(false); + connection.set_punctuation(Punctuation::All); + connection.say(Priority::Important, "This statement, unlike others, has punctuation that is spoken!".to_string()); + connection.set_punctuation(Punctuation::None); +} diff --git a/src/lib.rs b/src/lib.rs new file mode 100644 index 0000000..5817a9c --- /dev/null +++ b/src/lib.rs @@ -0,0 +1,511 @@ +#![allow(non_upper_case_globals)] +extern crate speech_dispatcher_sys; + +use std::ffi::{CStr, CString}; + +use speech_dispatcher_sys::*; + +pub enum Mode { + Single = SPDConnectionMode::SPD_MODE_SINGLE as isize, + Threaded = SPDConnectionMode::SPD_MODE_THREADED as isize, +} + +pub enum Priority { + Important = SPDPriority::SPD_IMPORTANT as isize, + Message = SPDPriority::SPD_MESSAGE as isize, + Text = SPDPriority::SPD_TEXT as isize, + Notification = SPDPriority::SPD_NOTIFICATION as isize, + Progress = SPDPriority::SPD_PROGRESS as isize, +} + +pub enum VoiceType { + Male1 = SPDVoiceType::SPD_MALE1 as isize, + Male2 = SPDVoiceType::SPD_MALE2 as isize, + Male3 = SPDVoiceType::SPD_MALE3 as isize, + Female1 = SPDVoiceType::SPD_FEMALE1 as isize, + Female2 = SPDVoiceType::SPD_FEMALE2 as isize, + Female3 = SPDVoiceType::SPD_FEMALE3 as isize, + ChildMale = SPDVoiceType::SPD_CHILD_MALE as isize, + ChildFemale = SPDVoiceType::SPD_CHILD_FEMALE as isize, +} + +pub struct Connection { + connection: *mut SPDConnection, +} + +pub type Address = SPDConnectionAddress; + +pub enum DataMode { + Text = SPDDataMode::SPD_DATA_TEXT as isize, + SSML = SPDDataMode::SPD_DATA_SSML as isize, +} + +pub enum Notification { + Begin = SPDNotification::SPD_BEGIN as isize, + End = SPDNotification::SPD_END as isize, + IndexMarks = SPDNotification::SPD_INDEX_MARKS as isize, + Cancel = SPDNotification::SPD_CANCEL as isize, + Pause = SPDNotification::SPD_PAUSE as isize, + Resume = SPDNotification::SPD_RESUME as isize, + All = SPDNotification::SPD_ALL as isize, +} + +pub enum Punctuation { + All = SPDPunctuation::SPD_PUNCT_ALL as isize, + None = SPDPunctuation::SPD_PUNCT_NONE as isize, + Some = SPDPunctuation::SPD_PUNCT_SOME as isize, +} + +pub enum CapitalLetters { + None = SPDCapitalLetters::SPD_CAP_NONE as isize, + Spell = SPDCapitalLetters::SPD_CAP_SPELL as isize, + Icon = SPDCapitalLetters::SPD_CAP_ICON as isize, +} + +fn i32_to_bool(v: i32) -> bool { + if v == 1 { true } else { false } +} + +impl Connection { + + pub fn open(client_name: String, connection_name: String, user_name: String, mode: Mode) -> Connection { + let connection = unsafe { + spd_open( + CString::new(client_name).unwrap().as_ptr(), + CString::new(connection_name).unwrap().as_ptr(), + CString::new(user_name).unwrap().as_ptr(), + mode as u32 + ) + }; + Connection {connection: connection } + } + + pub fn open2(client_name: String, connection_name: String, user_name: String, mode: Mode, address: *mut Address, autospawn: bool) -> Connection { + let auto_spawn = if autospawn { 1 } else { 0 }; + let error_result = vec![CString::new("").unwrap().into_raw()].as_mut_ptr(); + let connection = unsafe { + spd_open2( + CString::new(client_name).unwrap().as_ptr(), + CString::new(connection_name).unwrap().as_ptr(), + CString::new(user_name).unwrap().as_ptr(), + mode as u32, + address, + auto_spawn, + error_result + ) + }; + Connection { connection } + } + + pub fn close(&self) { + unsafe { spd_close(self.connection) }; + } + + pub fn say(&self, priority: Priority, text: String) -> bool { + let v = unsafe { + spd_say( + self.connection, + priority as u32, + CString::new(text).unwrap().as_ptr() + ) + }; + i32_to_bool(v) + } + + pub fn sayf(&self, priority: Priority, format: String) -> bool { + let v = unsafe { + spd_sayf( + self.connection, + priority as u32, + CString::new(format).unwrap().as_ptr() + ) + }; + i32_to_bool(v) + } + + pub fn stop(&self) -> bool { + let v = unsafe { spd_stop(self.connection) }; + i32_to_bool(v) + } + + pub fn stop_all(&self) -> bool { + let v = unsafe { spd_stop_all(self.connection) }; + i32_to_bool(v) + } + + pub fn stop_uid(&self, target_uid: i32) -> bool { + let v = unsafe { spd_stop_uid(self.connection, target_uid) }; + i32_to_bool(v) + } + + pub fn cancel(&self) -> bool { + let v = unsafe { spd_cancel(self.connection) }; + i32_to_bool(v) + } + + pub fn cancel_all(&self) -> bool { + let v = unsafe { spd_cancel_all(self.connection) }; + i32_to_bool(v) + } + + pub fn cancel_uid(&self, target_uid: i32) -> bool { + let v = unsafe { spd_cancel_uid(self.connection, target_uid) }; + i32_to_bool(v) + } + + pub fn pause(&self) -> bool { + let v = unsafe { spd_pause(self.connection) }; + i32_to_bool(v) + } + + pub fn ause_all(&self) -> bool { + let v = unsafe { spd_pause_all(self.connection) }; + i32_to_bool(v) + } + + pub fn pause_uid(&self, target_uid: i32) -> bool { + let v = unsafe { spd_pause_uid(self.connection, target_uid) }; + i32_to_bool(v) + } + + pub fn resume(&self) -> bool { + let v = unsafe { spd_resume(self.connection) }; + i32_to_bool(v) + } + + pub fn resume_all(&self) -> bool { + let v = unsafe { spd_resume_all(self.connection) }; + i32_to_bool(v) + } + + pub fn resume_uid(&self, target_uid: i32) -> bool { + let v = unsafe { spd_resume_uid(self.connection, target_uid) }; + i32_to_bool(v) + } + + pub fn key(&self, priority: Priority, key_name: String) -> bool { + let v = unsafe { + spd_key( + self.connection, + priority as u32, + CString::new(key_name).unwrap().as_ptr() + ) + }; + i32_to_bool(v) + } + + pub fn char(&self, priority: Priority, char: String) -> bool { + let v = unsafe { + spd_char( + self.connection, + priority as u32, + CString::new(char).unwrap().as_ptr() + ) + }; + i32_to_bool(v) + } + + pub fn wchar(&self, priority: Priority, wchar: i32) -> bool { + let v = unsafe { + spd_wchar( + self.connection, + priority as u32, + wchar, + ) + }; + i32_to_bool(v) + } + + pub fn sound_icon(&self, priority: Priority, icon_name: String) -> bool { + let v = unsafe { + spd_char( + self.connection, + priority as u32, + CString::new(icon_name).unwrap().as_ptr() + ) + }; + i32_to_bool(v) + } + + pub fn set_voice_type(&self, voice_type: VoiceType) -> bool { + let v = unsafe { spd_set_voice_type(self.connection, voice_type as u32) }; + i32_to_bool(v) + } + + pub fn set_voice_type_all(&self, voice_type: VoiceType) -> bool { + let v = unsafe { spd_set_voice_type_all(self.connection, voice_type as u32) }; + i32_to_bool(v) + } + + pub fn set_voice_type_uid(&self, voice_type: VoiceType, target_uid: u32) -> bool { + let v = unsafe { spd_set_voice_type_uid(self.connection, voice_type as u32, target_uid) }; + i32_to_bool(v) + } + + pub fn get_voice_type(&self) -> VoiceType { + let v = unsafe { spd_get_voice_type(self.connection) }; + match v { + SPDVoiceType::SPD_MALE1 => VoiceType::Male1, + SPDVoiceType::SPD_MALE2 => VoiceType::Male2, + SPDVoiceType::SPD_MALE3 => VoiceType::Male3, + SPDVoiceType::SPD_FEMALE1 => VoiceType::Female1, + SPDVoiceType::SPD_FEMALE2 => VoiceType::Female2, + SPDVoiceType::SPD_FEMALE3 => VoiceType::Female3, + SPDVoiceType::SPD_CHILD_MALE => VoiceType::ChildMale, + SPDVoiceType::SPD_CHILD_FEMALE => VoiceType::ChildFemale, + _ => panic!("Invalid voice type"), + } + } + + pub fn set_synthesis_voice(&self, voice_name: String) -> bool { + let v = unsafe { + spd_set_synthesis_voice( + self.connection, + CString::new(voice_name).unwrap().as_ptr() + ) + }; + i32_to_bool(v) + } + + pub fn set_synthesis_voice_all(&self, voice_name: String) -> bool { + let v = unsafe { + spd_set_synthesis_voice_all( + self.connection, + CString::new(voice_name).unwrap().as_ptr() + ) + }; + i32_to_bool(v) + } + + pub fn set_synthesis_voice_uid(&self, voice_name: String, target_uid: u32) -> bool { + let v = unsafe { + spd_set_synthesis_voice_uid( + self.connection, + CString::new(voice_name).unwrap().as_ptr(), + target_uid + ) + }; + i32_to_bool(v) + } + + pub fn set_data_mode(&self, mode: DataMode) -> bool { + let v = unsafe { + spd_set_data_mode( + self.connection, + mode as u32 + ) + }; + i32_to_bool(v) + } + + pub fn set_notification_on(&self, notification: Notification) -> bool { + let v = unsafe { + spd_set_notification_on( + self.connection, + notification as u32 + ) + }; + i32_to_bool(v) + } + + pub fn set_notification_off(&self, notification: Notification) -> bool { + let v = unsafe { + spd_set_notification_off( + self.connection, + notification as u32 + ) + }; + i32_to_bool(v) + } + + pub fn set_notification(&self, notification: Notification, state: String) -> bool { + let v = unsafe { + spd_set_notification( + self.connection, + notification as u32, + CString::new(state).unwrap().as_ptr() + ) + }; + i32_to_bool(v) + } + + pub fn set_voice_rate(&self, rate: i32) -> bool { + let v = unsafe { spd_set_voice_rate(self.connection, rate) }; + i32_to_bool(v) + } + + pub fn set_voice_rate_all(&self, rate: i32) -> bool { + let v = unsafe { spd_set_voice_rate_all(self.connection, rate) }; + i32_to_bool(v) + } + + pub fn set_voice_rate_uid(&self, rate: i32, target_uid: u32) -> bool { + let v = unsafe { spd_set_voice_rate_uid(self.connection, rate, target_uid) }; + i32_to_bool(v) + } + + pub fn get_voice_rate(&self) -> i32 { + unsafe { spd_get_voice_rate(self.connection) } + } + + pub fn set_voice_pitch(&self, pitch: i32) -> bool { + let v = unsafe { spd_set_voice_pitch(self.connection, pitch) }; + i32_to_bool(v) + } + + pub fn set_voice_pitch_all(&self, pitch: i32) -> bool { + let v = unsafe { spd_set_voice_pitch_all(self.connection, pitch) }; + i32_to_bool(v) + } + + pub fn set_voice_pitch_uid(&self, pitch: i32, target_uid: u32) -> bool { + let v = unsafe { spd_set_voice_pitch_uid(self.connection, pitch, target_uid) }; + i32_to_bool(v) + } + + pub fn get_voice_pitch(&self) -> i32 { + unsafe { spd_get_voice_pitch(self.connection) } + } + + pub fn set_volume(&self, volume: i32) -> bool { + let v = unsafe { spd_set_volume(self.connection, volume) }; + i32_to_bool(v) + } + + pub fn set_volume_all(&self, volume: i32) -> bool { + let v = unsafe { spd_set_volume_all(self.connection, volume) }; + i32_to_bool(v) + } + + pub fn set_volume_uid(&self, volume: i32, target_uid: u32) -> bool { + let v = unsafe { spd_set_volume_uid(self.connection, volume, target_uid) }; + i32_to_bool(v) + } + + pub fn get_volume(&self) -> i32 { + unsafe { spd_get_volume(self.connection) } + } + + pub fn set_punctuation(&self, punctuation: Punctuation) -> bool { + let v = unsafe { spd_set_punctuation(self.connection, punctuation as u32) }; + i32_to_bool(v) + } + + pub fn set_punctuation_all(&self, punctuation: Punctuation) -> bool { + let v = unsafe { spd_set_punctuation_all(self.connection, punctuation as u32) }; + i32_to_bool(v) + } + + pub fn set_punctuation_uid(&self, punctuation: Punctuation, target_uid: u32) -> bool { + let v = unsafe { spd_set_punctuation_uid(self.connection, punctuation as u32, target_uid) }; + i32_to_bool(v) + } + + pub fn set_capital_letters(&self, capital_letters: CapitalLetters) -> bool { + let v = unsafe { spd_set_capital_letters(self.connection, capital_letters as u32) }; + i32_to_bool(v) + } + + pub fn set_capital_letters_all(&self, capital_letters: CapitalLetters) -> bool { + let v = unsafe { spd_set_capital_letters_all(self.connection, capital_letters as u32) }; + i32_to_bool(v) + } + + pub fn set_capital_letters_uid(&self, capital_letters: CapitalLetters, target_uid: u32) -> bool { + let v = unsafe { spd_set_capital_letters_uid(self.connection, capital_letters as u32, target_uid) }; + i32_to_bool(v) + } + + pub fn set_spelling(&self, spelling: bool) -> bool { + let s = if spelling { SPDSpelling::SPD_SPELL_ON } else { SPDSpelling::SPD_SPELL_OFF }; + let v = unsafe { spd_set_spelling(self.connection, s) }; + i32_to_bool(v) + } + + pub fn set_spelling_all(&self, spelling: bool) -> bool { + let s = if spelling { SPDSpelling::SPD_SPELL_ON } else { SPDSpelling::SPD_SPELL_OFF }; + let v = unsafe { spd_set_spelling_all(self.connection, s) }; + i32_to_bool(v) + } + + pub fn set_spelling_uid(&self, spelling: bool, target_uid: u32) -> bool { + let s = if spelling { SPDSpelling::SPD_SPELL_ON } else { SPDSpelling::SPD_SPELL_OFF }; + let v = unsafe { spd_set_spelling_uid(self.connection, s, target_uid) }; + i32_to_bool(v) + } + + pub fn set_language(&self, language: String) -> bool { + let v = unsafe { + spd_set_language( + self.connection, + CString::new(language).unwrap().as_ptr() + ) + }; + i32_to_bool(v) + } + + pub fn set_language_all(&self, language: String) -> bool { + let v = unsafe { + spd_set_language_all( + self.connection, + CString::new(language).unwrap().as_ptr() + ) + }; + i32_to_bool(v) + } + + pub fn set_language_uid(&self, language: String, target_uid: u32) -> bool { + let v = unsafe { + spd_set_language_uid( + self.connection, + CString::new(language).unwrap().as_ptr(), + target_uid + ) + }; + i32_to_bool(v) + } + + pub fn get_language(&self) -> &str { + let v = unsafe { CStr::from_ptr(spd_get_language(self.connection)) }; + v.to_str().unwrap() + } + + pub fn set_output_module(&self, output_module: String) -> bool { + let v = unsafe { + spd_set_output_module( + self.connection, + CString::new(output_module).unwrap().as_ptr() + ) + }; + i32_to_bool(v) + } + + pub fn set_output_module_all(&self, output_module: String) -> bool { + let v = unsafe { + spd_set_output_module_all( + self.connection, + CString::new(output_module).unwrap().as_ptr() + ) + }; + i32_to_bool(v) + } + + pub fn set_output_module_uid(&self, output_module: String, target_uid: u32) -> bool { + let v = unsafe { + spd_set_output_module_uid( + self.connection, + CString::new(output_module).unwrap().as_ptr(), + target_uid + ) + }; + i32_to_bool(v) + } + + +} + +impl Drop for Connection { + fn drop(&mut self) { + self.close(); + } +}