public void ProcessEvent(PlayerEventArgs args, TrackInfo track, uint pos, uint len)
 {
     switch(args.Event) {
     case PlayerEvent.StateChange:
         StateChange((PlayerEventStateChangeArgs)args, track, pos, len);
         break;
     case PlayerEvent.TrackInfoUpdated:
         UpdateTrack(track, pos, len);
         break;
     case PlayerEvent.Iterate:
         UpdatePosition(pos, len);
         break;
     }
 }

 private void OnPlayerEvent (PlayerEventArgs args)
 {
     switch (args.Event) {
         case PlayerEvent.StartOfStream:
         case PlayerEvent.TrackInfoUpdated:
             player.AddPropertyChange (PlayerProperties.Metadata);
             break;
         case PlayerEvent.StateChange:
             player.AddPropertyChange (PlayerProperties.PlaybackStatus);
             break;
         case PlayerEvent.Seek:
             player.HandleSeek ();
             break;
         case PlayerEvent.Volume:
             player.AddPropertyChange (PlayerProperties.Volume);
             break;
     }
 }

        /// <summary>
        /// Callback for when player events occur
        /// </summary>
        /// <param name='args'>Event arguments</param>
        public void OnPlayerEvent(PlayerEventArgs args)
        {
            // Check what type of event it was - We need to know if playback
            // was stopped or started.
            switch (args.Event)
            {
                case PlayerEvent.StartOfStream:
                case PlayerEvent.TrackInfoUpdated:
                    UpdateStatus();
                    break;

                case PlayerEvent.EndOfStream:
                    OnStop();
                    break;

                case PlayerEvent.StateChange:
                    OnPlayerStateChange((PlayerEventStateChangeArgs)args);
                    break;
            }
        }

        private void OnPlayerEvent (PlayerEventArgs args)
        {
            if (args.Event == PlayerEvent.EndOfStream) {
                // If EoS is for the last track in the play queue
                if (this == ServiceManager.PlaybackController.Source &&
                    TrackModel.IndexOf (current_track) == Count - 1) {
                    SetCurrentTrack (null);
                    UpdatePlayQueue ();
                    if (was_playing) {
                        ServiceManager.PlaybackController.PriorTrack = prior_playback_track;
                    } else {
                        // Stop playback; nothing was playing before the play queue, so it doesn't
                        // make sense to continue playback.
                        ServiceManager.PlaybackController.StopWhenFinished = true;
                    }
                }

                if (ServiceManager.PlaybackController.StopWhenFinished) {
                    if (current_track != null && this == ServiceManager.PlaybackController.Source) {
                        int index = TrackModel.IndexOf (current_track) + 1;
                        SetCurrentTrack (index < Count ? TrackModel[index] as DatabaseTrackInfo : null);
                    }
                }
            } else if (args.Event == PlayerEvent.StartOfStream) {
                if (TrackModel.IndexOf (ServiceManager.PlayerEngine.CurrentTrack) != -1) {
                    SetCurrentTrack (ServiceManager.PlayerEngine.CurrentTrack as DatabaseTrackInfo);
                    SetAsPlaybackSourceUnlessPlaying ();
                    UpdatePlayQueue ();
                } else {
                    prior_playback_track = ServiceManager.PlayerEngine.CurrentTrack;
                }
            }
        }

        private void OnEngineEventChanged(PlayerEventArgs args)
        {
            if (CurrentTrack != null) {
                if (args.Event == PlayerEvent.Error
                    && CurrentTrack.PlaybackError == StreamPlaybackError.None) {
                    CurrentTrack.SavePlaybackError (StreamPlaybackError.Unknown);
                } else if (args.Event == PlayerEvent.Iterate
                    && CurrentTrack.PlaybackError != StreamPlaybackError.None) {
                    CurrentTrack.SavePlaybackError (StreamPlaybackError.None);
                }
            }

            if (args.Event == PlayerEvent.StartOfStream) {
                incremented_last_played = false;
            } else if (args.Event == PlayerEvent.EndOfStream) {
                IncrementLastPlayed ();
            }

            RaiseEvent (args);

            // Do not raise iterate across DBus to avoid so many calls;
            // DBus clients should do their own iterating and
            // event/state checking locally
            if (args.Event == PlayerEvent.Iterate) {
                return;
            }

            DBusPlayerEventHandler dbus_handler = dbus_event_changed;
            if (dbus_handler != null) {
                dbus_handler (args.Event.ToString ().ToLower (),
                    args is PlayerEventErrorArgs ? ((PlayerEventErrorArgs)args).Message : String.Empty,
                    args is PlayerEventBufferingArgs ? ((PlayerEventBufferingArgs)args).Progress : 0
                );
            }
        }

        private void OnPlayerEvent(PlayerEventArgs args)
        {
            switch (args.Event) {
                case PlayerEvent.StartOfStream:
                case PlayerEvent.TrackInfoUpdated:
                    current_track = ServiceManager.PlayerEngine.CurrentTrack;
                    ToggleRatingMenuSensitive ();
                    ShowTrackNotification ();
                    break;
                case PlayerEvent.StateChange:
                    UpdateActions ();
                    break;
                case PlayerEvent.EndOfStream:
                    current_track = null;
                    ToggleRatingMenuSensitive ();
                    break;
            }

            if (notif_area != null) {
                notif_area.OnPlayerEvent (args);
            }
        }

 /// <summary>
 /// Handles EndOfStream events and stops recording
 /// </summary>
 /// <param name="args">
 /// A <see cref="PlayerEventArgs"/>
 /// </param>
 private void OnEndOfStream(PlayerEventArgs args)
 {
     if (recording) {
         StopRecording ();
     }
 }

 /// <summary>
 /// Handles Player state changes and Stops recording if appropriate
 /// </summary>
 /// <param name="args">
 /// A <see cref="PlayerEventArgs"/>
 /// </param>
 private void OnStateChange(PlayerEventArgs args)
 {
     if (ServiceManager.PlayerEngine.CurrentState == PlayerState.Idle && recording) {
         StopRecording ();
     }
 }

        private void OnPlayerEvent(PlayerEventArgs args)
        {
            parser.ProcessEvent(args,
                ServiceManager.PlayerEngine.CurrentTrack,
                ServiceManager.PlayerEngine.Position,
                ServiceManager.PlayerEngine.Length);

            if (args.Event == PlayerEvent.StateChange)
            {
                switch(((PlayerEventStateChangeArgs)args).Current)
                {
                case PlayerState.NotReady:
                case PlayerState.Ready:
                case PlayerState.Idle:
                case PlayerState.Contacting:
                case PlayerState.Loading:
                case PlayerState.Loaded:
                    idlescreen.prio = LCDScreen.Prio.Foreground;
                    lcdclient.UpdScreen(idlescreen);
                    foreach(LCDScreen screen in userscreens.Keys)
                    {
                        screen.prio = LCDScreen.Prio.Hidden;
                        lcdclient.UpdScreen(screen);
                    }
                    break;
                case PlayerState.Playing:
                case PlayerState.Paused:
                    idlescreen.prio = LCDScreen.Prio.Hidden;
                    lcdclient.UpdScreen(idlescreen);
                    foreach(LCDScreen screen in userscreens.Keys)
                    {
                        screen.prio = LCDScreen.Prio.Foreground;
                        lcdclient.UpdScreen(screen);
                    }
                    break;
                }
            }
            lcdclient.UpdWidgetsAll(parser);
        }

 private void RaiseEventChanged (PlayerEventArgs args)
 {
     PlayerEventHandler handler = EventChanged;
     if (handler != null) {
         handler (args);
     }
 }

        private void OnPlayerEvent (PlayerEventArgs args)
        {
            switch (args.Event) {
                case PlayerEvent.StartOfStream:
                    CurrentTrack = player_engine.CurrentTrack;
                    consecutive_errors = 0;
                    break;
                case PlayerEvent.EndOfStream:
                    EosTransition ();
                    break;
                case PlayerEvent.Error:
                    if (++consecutive_errors >= 5) {
                        consecutive_errors = 0;
                        player_engine.Close (false);
                        OnStopped ();
                        break;
                    }

                    CancelErrorTransition ();
                    // TODO why is this so long? any reason not to be instantaneous?
                    error_transition_id = Application.RunTimeout (250, delegate {
                        EosTransition ();
                        RequestTrackHandler ();
                        return true;
                    });
                    break;
                case PlayerEvent.StateChange:
                    if (((PlayerEventStateChangeArgs)args).Current != PlayerState.Loading) {
                        break;
                    }

                    TrackInfo track = player_engine.CurrentTrack;
                    if (changing_to_track != track && track != null) {
                        CurrentTrack = track;
                    }

                    changing_to_track = null;

                    if (!raise_started_after_transition) {
                        transition_track_started = false;
                        OnTrackStarted ();
                    } else {
                        transition_track_started = true;
                    }
                    break;
                case PlayerEvent.RequestNextTrack:
                    RequestTrackHandler ();
                    break;
            }
        }

        protected virtual void OnEventChanged(PlayerEventArgs args)
        {
            if (args.Event == PlayerEvent.StartOfStream && pending_track != null) {
                Log.DebugFormat ("OnEventChanged called with StartOfStream.  Replacing current_track with pending_track: \"{0}\"",
                                 pending_track.DisplayTrackTitle);
                CurrentTrackTimeStamp = DateTime.Now;
                current_track = pending_track;
                pending_track = null;
            }

            ThreadAssist.ProxyToMain (() => RaiseEventChanged (args));
        }

        protected virtual void OnEventChanged (PlayerEventArgs args)
        {
            if (args.Event == PlayerEvent.StartOfStream && pending_track != null) {
                Log.DebugFormat ("OnEventChanged called with StartOfStream.  Replacing current_track with pending_track: \"{0}\"",
                                 pending_track.DisplayTrackTitle);
                current_track = pending_track;
                current_uri = pending_uri;
                pending_track = null;
                pending_uri = null;
            }

            if (ThreadAssist.InMainThread) {
                RaiseEventChanged (args);
            } else {
                ThreadAssist.ProxyToMain (delegate {
                    RaiseEventChanged (args);
                });
            }
        }

        void playerEvent_Handler(PlayerEventArgs e)
        {
            if(e.Event == PlayerEvent.StartOfStream && current_track != ServiceManager.PlaybackController.CurrentTrack)
            {
                try {
                    if (current_track != null) {
                        StopTrack (current_track);
                    }

                    Log.Debug("TrackStarted: "+ServiceManager.PlaybackController.CurrentTrack.TrackTitle);
                    Event ev = CreateZgEvent (ServiceManager.PlaybackController.CurrentTrack, Interpretation.Instance.EventInterpretation.AccessEvent);
                    client.InsertEvents (new List<Event> () {ev});

                    current_track = ServiceManager.PlaybackController.CurrentTrack;
                } catch (Exception ex) {
                    Log.Exception (ex);
                }
            }
        }

 private void OnPlayerEvent(PlayerEventArgs args)
 {
     ToggleVideoVisibility ();
 }

 private void OnTrackInfoUpdated(PlayerEventArgs args)
 {
     CheckForSwitch ();
 }

        private void RaiseEvent(PlayerEventArgs args)
        {
            lock (event_handlers) {
                if (args.Event == PlayerEvent.StateChange && args is PlayerEventStateChangeArgs) {
                    HandleStateChange ((PlayerEventStateChangeArgs)args);
                }

                LinkedListNode<PlayerEventHandlerSlot> node = event_handlers.First;
                while (node != null) {
                    if ((node.Value.EventMask & args.Event) == args.Event) {
                        try {
                            node.Value.Handler (args);
                        } catch (Exception e) {
                            Log.Exception (String.Format ("Error running PlayerEngine handler for {0}", args.Event), e);
                        }
                    }
                    node = node.Next;
                }
            }
        }

        private void OnPlayerEvent(PlayerEventArgs args)
        {
            if (((PlayerEventStateChangeArgs)args).Current == PlayerState.Loaded &&
                track_model.Contains (ServiceManager.PlayerEngine.CurrentTrack)) {
                CurrentTrack = ServiceManager.PlayerEngine.CurrentTrack;

                lock (track_model) {
                    // Remove all but 5 played or skipped tracks
                    if (current_track > 5) {
                        for (int i = 0; i < (current_track - 5); i++) {
                            track_model.Remove (track_model[0]);
                        }
                        current_track = 5;
                    }

                    // Set all previous tracks as CanPlay = false
                    foreach (TrackInfo track in track_model) {
                        if (track == CurrentTrack)
                            break;
                        if (track.CanPlay) {
                            track.CanPlay = false;
                        }
                    }
                    OnUpdated ();
                }

                if (TracksLeft <= 2) {
                    Refresh ();
                }
            }
        }

        private void OnPlayerEvent(PlayerEventArgs args)
        {
            book_track = ServiceManager.PlayerEngine.CurrentTrack as DatabaseTrackInfo;
            if (book_track == null || book_track.PrimarySourceId != this.DbId) {
                book_track = null;
            }

            switch (args.Event) {
                case PlayerEvent.StartOfStream:
                    if (book_track != null) {
                        StartTimeout ();

                        if (PlaybackSource.Book == null || PlaybackSource.Book.DbId != book_track.AlbumId) {
                            PlaybackSource.Book = DatabaseAlbumInfo.Provider.FetchSingle (book_track.AlbumId);
                        }

                        if (book_track.CacheModelId != PlaybackSource.DatabaseTrackModel.CacheId) {
                            var index = PlaybackSource.DatabaseTrackModel.IndexOfFirst (book_track);
                            if (index >= 0) {
                                ServiceManager.PlaybackController.PriorTrack = PlaybackSource.TrackModel [index];
                            } else {
                                Log.Error ("Audiobook track started, but couldn't find in the Audiobook.PlaybackSource");
                            }
                        }
                    }
                    break;
                case PlayerEvent.EndOfStream:
                    StopTimeout ();
                    break;
                case PlayerEvent.Seek:
                    UpdateLastPlayed ();
                    break;
            }
        }

 private void OnPlayerEvent(PlayerEventArgs args)
 {
     if (ContactContainerSource.ShareCurrentlyPlayingSchema.Get ()) {
         switch (args.Event) {
             case PlayerEvent.StartOfStream:
                 //AnnounceTrack (ServiceManager.PlayerEngine.CurrentTrack);
                 break;
             case PlayerEvent.StateChange:
                 PlayerEventStateChangeArgs state = args as PlayerEventStateChangeArgs;
                 if (state != null) {
                     switch (state.Current) {
                         case PlayerState.Paused:
                             announcer.Announce (String.Empty);
                             break;
                         case PlayerState.Playing:
                             AnnounceTrack (ServiceManager.PlayerEngine.CurrentTrack);
                             break;
                     }
                 }
                 break;
         }
     }
 }