/// <summary>
/// Initializes the wrapper.
/// </summary>
/// <param name="audioSourceDirectory">The directory of the audio source.</param>
/// <returns>True if successful.</returns>
public bool Initialize(string audioSourceDirectory)
{
try
{
_logger = AudioBandLogManager.GetLogger($"AudioSourceWrapper({new DirectoryInfo(audioSourceDirectory).Name})");
_logger.Debug("Initializing wrapper");
AppDomain.CurrentDomain.UnhandledException += (o, e) => _logger.Error(e.ExceptionObject as Exception, "Unhandled exception in wrapper");
_audioSource = AudioSourceLoader.LoadFromDirectory(audioSourceDirectory);
_audioSource.Logger = new AudioSourceLogger(_audioSource.Name);
_audioSource.SettingChanged += (o, e) => SettingChanged?.Invoke(this, e);
_audioSource.TrackInfoChanged += (o, e) => TrackInfoChanged?.Invoke(this, e);
_audioSource.IsPlayingChanged += (o, e) => IsPlayingChanged?.Invoke(this, e);
_audioSource.TrackProgressChanged += (o, e) => TrackProgressChanged?.Invoke(this, e);
_audioSource.VolumeChanged += (o, e) => VolumeChanged?.Invoke(this, e);
_audioSource.ShuffleChanged += (o, e) => ShuffleChanged?.Invoke(this, e);
_audioSource.RepeatModeChanged += (o, e) => RepeatModeChanged?.Invoke(this, e);
_audioSourceSettingsList = _audioSource.GetSettings();
foreach (AudioSourceSetting setting in _audioSourceSettingsList)
{
_audioSourceSettings.Add(setting.Attribute.Name, setting);
}
_logger.Debug("Wrapper initialization complete");
return(true);
}
catch (Exception e)
{
_logger.Error(e);
return(false);
}
}
private void Bar_VolumeChanged(double volume)
{
var value = (int)(volume * 100);
Dispatcher.Invoke(() => { MPVInterop.Instance.SetProperty("volume", value.ToString(CultureInfo.InvariantCulture)); });
VolumeChanged?.Invoke(volume);
}
public void SelectTrack(int index)
{
if (_trackList.Count == 0)
{
return;
}
CurrentTrackIndex = index;
if (CurrentTrackIndex >= _trackList.Count)
{
CurrentTrackIndex = _trackList.Count - 1;
}
if (CurrentTrackIndex < 0)
{
CurrentTrackIndex = 0;
}
if (CurrentTrack.Media != null)
{
_windowsMediaPlayer.currentMedia = CurrentTrack.Media;
}
ProgressChanged?.Invoke(this, ProgressRaw);
TrackSelected?.Invoke(this, CurrentTrack);
VolumeChanged?.Invoke(this, Volume);
_timer.Start();
}
public override void OnRouteVolumeChanged(MediaRouter router, MediaRouter.RouteInfo info)
{
VolumeChanged?.Invoke(router, new VolumeChangedEventArgs {
Volume = info.Volume,
PlaybackStream = info.PlaybackStream,
});
}
private void sVolume_VolumeChanged(object sender, RoutedPropertyChangedEventArgs <double> e)
{
VolumeChanged?.Invoke(e.NewValue);
if (Volume == 0)
{
btnVolume.ActiveImageUri = Resources["Image_Volume_0_Hover"] as System.Uri;
btnVolume.InactiveImageUri = Resources["Image_Volume_0"] as System.Uri;
btnVolumeHide.ActiveImageUri = btnVolume.ActiveImageUri;
btnVolumeHide.InactiveImageUri = btnVolume.InactiveImageUri;
}
else if (Volume > 0 && Volume < 33)
{
btnVolume.ActiveImageUri = Resources["Image_Volume_33_Hover"] as System.Uri;
btnVolume.InactiveImageUri = Resources["Image_Volume_33"] as System.Uri;
btnVolumeHide.ActiveImageUri = btnVolume.ActiveImageUri;
btnVolumeHide.InactiveImageUri = btnVolume.InactiveImageUri;
}
else if (Volume >= 33 && Volume < 66)
{
btnVolume.ActiveImageUri = Resources["Image_Volume_66_Hover"] as System.Uri;
btnVolume.InactiveImageUri = Resources["Image_Volume_66"] as System.Uri;
btnVolumeHide.ActiveImageUri = btnVolume.ActiveImageUri;
btnVolumeHide.InactiveImageUri = btnVolume.InactiveImageUri;
}
else if (Volume >= 66)
{
btnVolume.ActiveImageUri = Resources["Image_Volume_100_Hover"] as System.Uri;
btnVolume.InactiveImageUri = Resources["Image_Volume_100"] as System.Uri;
btnVolumeHide.ActiveImageUri = btnVolume.ActiveImageUri;
btnVolumeHide.InactiveImageUri = btnVolume.InactiveImageUri;
}
}
private void Sl_ValueChanged(object sender, RoutedPropertyChangedEventArgs <double> e)
{
var slider = (Slider)e.Source;
var vol = (UserVolume)slider.DataContext;
var newVol = new UserVolume(vol.UserID, (float)slider.Value);
VolumeChanged?.Invoke(sender, newVol);
}
public VolumeService()
{
audioManager = (AudioManager)CrossCurrentActivity.Current.Activity.GetSystemService(Context.AudioService);
MessagingCenter.Subscribe <MainActivity>(this, MainActivity.VolumeChangeMessage, (sender) =>
{
VolumeChanged?.Invoke(this, new VolumeChangedEventArgs(0));
});
}
public void VolumeChange(int step)
{
if (_locked == false)
{
Volume += step;
}
VolumeChanged?.Invoke(Songs, PlayingSong, _locked, _volume);
Console.WriteLine($"Volume has been changed by {step}");
}
public void VolumeDown()
{
if (_locked == false)
{
Volume--;
}
VolumeChanged?.Invoke(null, null, _locked, _volume);
Console.WriteLine("Volume has been decreased");
}
private void OnVolumeChanged(object sender, AudioSessionSimpleVolumeChangedEventArgs e)
{
if (!_isNotifyEnabled)
{
_isNotifyEnabled = true;
return;
}
VolumeChanged?.Invoke(this);
}
private static void OnVolumeChanged(float volume)
{
if (VolumeChanged != null)
{
VolumeChanged.Invoke(null, new VolumeChangedEventArgs
{
Volume = volume
});
}
}
public void SetVolume(VideoLayer videolayer, double volume, int transitionDuration)
{
var channel = _casparChannel;
if (CheckConnected(channel))
{
channel.Volume((int)videolayer, (float)volume, transitionDuration, Easing.Linear);
VolumeChanged?.Invoke(this, new VolumeChangedEventArgs(videolayer, volume));
}
}
protected override void OnVolumeChanged(VolumeChanged e)
{
base.OnVolumeChanged(e);
if (m_volumeSlider != null && !m_isDraggingVolumeSlider)
{
m_volumeSlider.value = e.Volume;
m_volumeSlider.maxValue = e.MaxVolume;
}
}
private void OnEndpointVolumeChanged(object sender, AudioEndpointVolumeCallbackEventArgs e)
{
if (!_isNotifyEnabled)
{
_isNotifyEnabled = true;
return;
}
VolumeChanged?.Invoke(this);
}
void IAudioSessionEventsHandler.OnVolumeChanged(float volume, bool isMuted)
{
if (!_isNotifyEnabled)
{
_isNotifyEnabled = true;
return;
}
VolumeChanged?.Invoke(this);
}
private void DoTick()
{
_previousContext = _currentContext;
try
{
_currentContext = _api.GetPlayback();
}
catch (SpotifyWebApiException ex)
{
MessageBox.Show(ex.Message);
Thread.Sleep(5000);
return;
}
try
{
if (_currentContext == null)
{
return;
}
// Check volume change
if (CompareContext(c => c.Device?.VolumePercent, out var oldVolume, out var newVolume))
{
// Volume Changed
VolumeChanged?.Invoke(this,
new VolumeChangeEventArgs(oldVolume.GetValueOrDefault(),
newVolume.GetValueOrDefault()));
}
if (CompareContext(c => c.Item, out var oldTrack, out var newTrack))
{
// Track Changed
TrackChanged?.Invoke(this, new TrackChangeEventArgs(oldTrack, newTrack));
}
if (CompareContext(c => c.IsPlaying))
{
// Playstate Changed
PlayStateChanged?.Invoke(this, new PlayStateChangeEventArgs(_currentContext.IsPlaying));
}
if (CompareContext(c => c.ProgressMs, out var oldProgressMs, out var newProgressMs))
{
// Track Time Changed
TrackTimeChanged?.Invoke(this,
new TrackTimeChangeEventArgs(TimeSpan
.FromMilliseconds(newProgressMs)));
}
Tick?.Invoke(this, new EventArgs());
}
catch { }
}
private void NotifyVolume()
{
int volume = _itunesControls.Volume;
if (volume == _volume)
{
return;
}
_volume = volume;
VolumeChanged?.Invoke(this, _volume / 100f);
}
private void NotifyVolume()
{
var volume = _ipc.GetVolume();
if (volume == _volume)
{
return;
}
_volume = volume;
VolumeChanged?.Invoke(this, _volume / 100f);
}
/// <summary>
/// RPGアツマールのマスター音量を変更したときの通知イベントを処理します
/// </summary>
/// <param name="volume">変更された音量（OFF 0.0 ～ 1.0 ON）</param>
private void OnVolumeChanged(float volume)
{
// 自動同期が有効なら
if (enableAutoVolumeSync)
{
// 現在のマスター音量をそのまま設定する
AudioListener.volume = volume;
}
// イベントを呼ぶ
VolumeChanged?.Invoke(volume);
}
protected override void OnApplyTemplate()
{
MediaElement = (MediaElement)GetTemplateChild("MainMediaElement");
if (MediaElement != null)
{
MediaElement.CurrentStateChanged += (s, e) => CurrentStateChanged?.Invoke(this, e);
MediaElement.MediaEnded += (s, e) => MediaEnded?.Invoke(this, e);
MediaElement.MediaOpened += (s, e) => MediaOpened?.Invoke(this, e);
MediaElement.MediaFailed += (s, e) => MediaFailed?.Invoke(this, e);
MediaElement.SeekCompleted += (s, e) => SeekCompleted?.Invoke(this, e);
MediaElement.VolumeChanged += (s, e) => VolumeChanged?.Invoke(this, e);
}
base.OnApplyTemplate();
}
/// <summary>
/// Connects to SignalR
/// </summary>
public async Task ConnectAsync()
{
connection = new HubConnectionBuilder()
.WithUrl(_hubUrl)
.Build();
connection.On <CurrentlyPlaying>("SongChanged", (song) => SongChanged?.Invoke(song));
connection.On <PlaylistItem>("PlaylistChanged", (playlist) => PlaylistChanged?.Invoke(playlist));
connection.On <int>("VolumeChanged", (volume) => VolumeChanged?.Invoke(volume));
connection.On("Paused", () => Paused?.Invoke());
connection.On("Resumed", () => Resumed?.Invoke());
await connection.StartAsync();
}
private void OnReceiveReceiverStatus(MessageReceiverStatus receiverStatusMessage)
{
if (receiverStatusMessage != null && receiverStatusMessage.status != null && receiverStatusMessage.status.applications != null)
{
currentVolume = receiverStatusMessage.status.volume;
VolumeChanged?.Invoke(this, currentVolume);
var deviceApplication = receiverStatusMessage.status.applications.Where(a => a.appId.Equals("CC1AD845"));
if (deviceApplication.Any())
{
chromeCastDestination = deviceApplication.First().transportId;
chromeCastApplicationSessionNr = deviceApplication.First().sessionId;
}
}
}
public void Clear()
{
var channel = _casparChannel;
if (CheckConnected(channel))
{
channel.Clear();
channel.ClearMixer((int)VideoLayer.Program);
_outputAspectNarrow[VideoLayer.Program] = false;
_visible.Clear();
_loadedNext.Clear();
VolumeChanged?.Invoke(this, new VolumeChangedEventArgs(VideoLayer.Program, 1));
Debug.WriteLine(this, "CasparClear");
}
}
public void SetVolume(int volume)
{
if (Volume == volume)
{
return;
}
int oldVolume = Volume;
Volume = volume <MinVolume?MinVolume : volume> MaxVolume ? MaxVolume : volume;
if (SoundOut.IsReady)
{
SoundOut.Out.Volume = Math.Min(1.0f, Math.Max(volume / 100f, 0f));
}
VolumeChanged?.Invoke(this, new VolumeChangedEventArgs(oldVolume, volume));
}
public ControlBar()
{
InitializeComponent();
this.Background = new SolidColorBrush(Colors.Transparent);
Seekbar.TimePositionChanged += Seekbar_OnTimePositionChange;
Seekbar.PositionChanged += (position) => PositionChanged?.Invoke(position);
Volume.VolumeChanged += (volume) => VolumeChanged?.Invoke(volume);
Play.PlayStateChanged += (play) => PlayStateChanged?.Invoke(play);
Maximize.Clicked += () => MaximizeClicked?.Invoke();
Menu.AudioClicked += () => AudiosClicked?.Invoke();
Menu.SubtitlesClicked += () => SubtitlesClicked?.Invoke();
Menu.ExitClicked += () => ExitClicked?.Invoke();
Menu.ConfigClicked += () => ConfigClicked?.Invoke();
this.MouseLeave += ControlBar_MouseLeave;
this.MouseEnter += ControlBar_MouseEnter;
}
private void InitEvents()
{
Closing += delegate
{
ViewClosing?.Invoke();
};
numericInterval.ValueChanged += delegate
{
IntervalChanged?.Invoke((uint)numericInterval.Value);
};
checkRepeat.CheckedChanged += delegate
{
RepeatChanged?.Invoke(checkRepeat.Checked);
};
checkRandom.CheckedChanged += delegate
{
RandomChanged?.Invoke(checkRandom.Checked);
};
trackSpeed.ValueChanged += delegate
{
SpeedChanged?.Invoke(trackSpeed.Value);
UpdateLabelSpeed();
};
trackVolume.ValueChanged += delegate
{
VolumeChanged?.Invoke(trackVolume.Value);
UpdateLabelVolume();
};
comboVoice.SelectedValueChanged += delegate
{
VoiceChanged?.Invoke(comboVoice.SelectedItem?.ToString());
};
trackTimbre.ValueChanged += delegate
{
TimbreChanged?.Invoke(trackTimbre.Value);
UpdateLabelTimbre();
};
}
void SetDevice()
{
var device = _mmDeviceEnumerator.GetDefaultAudioEndpoint(EDataFlow.eRender, ERole.eMultimedia);
if (_mmDevice != null)
{
_mmDevice.AudioEndpointVolume.OnVolumeNotification -= AudioEndpointVolume_OnVolumeNotification;
}
_mmDevice = device;
//strange behaviour:
var audioMeterInformation = _mmDevice.AudioMeterInformation;
var deviceAudioSessionManager = _mmDevice.AudioSessionManager;
_mmDevice.AudioEndpointVolume.OnVolumeNotification += AudioEndpointVolume_OnVolumeNotification;
VolumeChanged?.Invoke(this, EventArgs.Empty);
}
public void ProcVolumeChanged()
{
VolumeChanged?.InvokeOnMainThread(this);
}
private void OnSessionVolumeChanged(IAudioSession session)
{
VolumeChanged?.Invoke(session);
}
private void AudioEndpointVolume_OnVolumeNotification(object sender, VolumeNotificationEventArgs e)
{
VolumeChanged?.Invoke(this, EventArgs.Empty);
}
