DCSIMG
Get ready for Windows Phone 7.5 – Part 3 – Background Audio (Hebrew) - Essential WPF

Get ready for Windows Phone 7.5 – Part 3 – Background Audio (Hebrew)

בפוסט הקודם דיברתי על Fast Application Switching, אחת מהיכולות החדשות והחשובות בגרסה החדשה של Windows Phone. בפוסט זה אציג תכונה חדשה שנקראת Background Audio המאפשרת ניגון ושליטה על אודיו ברקע.
הרעיון המרכזי בגרסה החדשה הוא לאפשר למשתמש לבצע פעולות ברקע, ועם זאת מבלי שה-Process ירוץ במקביל ויבזבז משאבים יקרים.
אחת מהפעולות שניתן להריץ ברקע בשיטה זו הינה ניגון ושליטה על אודיו מקוד שאתם כתבתם.
לדוגמה, אתם מעונינים ליצור נגן מדיה חדש, עם יכולות שלא קיימות בנגן המקורי. עם זאת אתם מעונינים שהמוסיקה תמשיך לנגן ברקע, תחליף שירים וניתן יהיה לשלוט עליה בעזרת הכפתורים הסטנדרטיים, למרות שיצאתם מהאפליקציה.
בפועל, יש שני סוגי אפליקציות של Background Audio. אחד שמנגן מדיה מקומית, והשני Stream.
 
Audio Playback Agent
כדי ליצור Background Audio שמנגן מדיה מקומית יש ליצור פרוייקט חדש מסוג Windows Phone Audio Playback Agent (זה בנוסף לפרוייקט הרגיל שמייצג את האפליקציה שלכם). בפרוייקט שמייצג את האפליקציה עצמה יש להוסיף Reference לפרוייקט שמכיל את ה- Agent.
 
imageimageimage
 
מימוש Audio Playback Agent
הרעיון מאחורי ה- Agent הוא למעשה אובייקט שרץ ברקע ומנוהל ע"י הסביבה עצמה. הסביבה שולחת פקודות לאובייקט זה כשיש בקשה לנגן קובץ אחר, לעצור את המוסיקה, וכו'.
להלן קטע קוד שמדגים כיצד לממש אובייקט זה:
 
Code Snippet
  1. public class AudioPlayer : AudioPlayerAgent
  2. {
  3.     private static readonly AudioTracks _tracks = new AudioTracks();
  5.     /// <summary>
  6.     /// Called when the playstate changes, except for the Error state (see OnError)
  7.     /// </summary>
  8.     /// <param name="player">The BackgroundAudioPlayer</param>
  9.     /// <param name="track">The track playing at the time the playstate changed</param>
  10.     /// <param name="playState">The new playstate of the player</param>
  11.     /// <remarks>
  12.     /// Play State changes cannot be cancelled. They are raised even if the application
  13.     /// caused the state change itself, assuming the application has opted-in to the callback
  14.     /// </remarks>
  15.     protected override void OnPlayStateChanged(BackgroundAudioPlayer player, AudioTrack track, PlayState playState)
  16.     {
  17.         switch (playState)
  18.         {
  19.             case PlayState.TrackReady:
  20.                 player.Play();
  21.                 break;
  23.             case PlayState.TrackEnded:
  24.                 SetNextTrack(player);
  25.                 break;
  26.         }
  28.         NotifyComplete();
  29.     }
  31.     /// <summary>
  32.     /// Called when the user requests an action using system-provided UI and the application has requesed
  33.     /// notifications of the action
  34.     /// </summary>
  35.     /// <param name="player">The BackgroundAudioPlayer</param>
  36.     /// <param name="track">The track playing at the time of the user action</param>
  37.     /// <param name="action">The action the user has requested</param>
  38.     /// <param name="param">The data associated with the requested action.
  39.     /// In the current version this parameter is only for use with the Seek action,
  40.     /// to indicate the requested position of an audio track</param>
  41.     /// <remarks>
  42.     /// User actions do not automatically make any changes in system state; the agent is responsible
  43.     /// for carrying out the user actions if they are supported
  44.     /// </remarks>
  45.     protected override void OnUserAction(BackgroundAudioPlayer player, AudioTrack track, UserAction action, object param)
  46.     {
  47.         switch (action)
  48.         {
  49.             case UserAction.Play:
  50.                 SetCurrentTrack(player);
  51.                 break;
  53.             case UserAction.Pause:
  54.                 player.Pause();
  55.                 break;                               
  57.             case UserAction.SkipNext:
  58.                 SetNextTrack(player);
  59.                 break;
  60.                 
  61.             case UserAction.SkipPrevious:
  62.                 SetPrevTrack(player);
  63.                 break;                
  64.         }
  66.         NotifyComplete();
  67.     }
  69.     private void SetCurrentTrack(BackgroundAudioPlayer player)
  70.     {
  71.         player.Track = _tracks.Current;
  72.     }
  74.     private void SetNextTrack(BackgroundAudioPlayer player)
  75.     {
  76.         _tracks.Next();
  77.         SetCurrentTrack(player);
  78.     }
  80.     private void SetPrevTrack(BackgroundAudioPlayer player)
  81.     {
  82.         _tracks.Prev();
  83.         SetCurrentTrack(player);
  84.     }
  86.     /// <summary>
  87.     /// Called whenever there is an error with playback, such as an AudioTrack not downloading correctly
  88.     /// </summary>
  89.     /// <param name="player">The BackgroundAudioPlayer</param>
  90.     /// <param name="track">The track that had the error</param>
  91.     /// <param name="error">The error that occured</param>
  92.     /// <param name="isFatal">If true, playback cannot continue and playback of the track will stop</param>
  93.     /// <remarks>
  94.     /// This method is not guaranteed to be called in all cases. For example, if the background agent
  95.     /// itself has an unhandled exception, it won't get called back to handle its own errors.
  96.     /// </remarks>
  97.     protected override void OnError(BackgroundAudioPlayer player, AudioTrack track, Exception error, bool isFatal)
  98.     {
  99.         //TODO: Add code to handle error conditions
  101.         NotifyComplete();
  102.     }
  104.     /// <summary>
  105.     /// Called when the agent request is getting cancelled
  106.     /// </summary>
  107.     protected override void OnCancel()
  108.     {
  109.     }
  110. }
 
בקטע קוד הנ"ל ניתן לראות כי AudioPlayer יורש מ- AudioPlayerAgent ובכך מנוהל ע"י הסביבה לרוץ כ- Agent ברקע. הרעיון פה הוא לדעת כיצד לתפעל את BackgroundAudioPlayer שמבצע את ניגון האודיו ברקע בפועל.
 
המטודה OnPlayStateChanged פועלת בכל פעם שמשתנה מצב ב- BackgroundAudioPlayer, בין אם בעקבות פעולת המשתמש או בעקבות אירוע מעניין בסגנן "הסתיימה רצועת השמעה" או "רצועה חדשה מתחילה" וכו'. כאן תפקידנו להחליט מה אנחנו עושים.
 
בדוגמה שהבאתי פה, הגבתי ל- TackReady. פה אני מתחיל לנגן את רצועת השמע החדשה/נוכחית. באירוע TrackEnded אני מנגן את הרצועה הבאה. קריאה למטודה פרטית שכתבתי, SetNextTrack, קובעת את הרצועה הבאה באופן מעגלי כאשר כל הרצועות ידועות מראש למען הפשטות.
 
המטודה OnUserAction פועלת בכל פעם שהמשתמש ביצע פעולת אודיו. פה אני מטפל ב- Play, Pause, SkipNext ו- SkipPrevious בהתאמה.
שימו לב כי המימוש הוא חלקי. יש אירועים נוספים לא טיפלתי בהם, וגם צריך לטפל במקרי שגיאה.
 
כעת נותר להוסיף אל פרויקט האפליקציה עצמה קבצי Audio ולהפעיל את ה- Agent. שימו לב: את קבצי ה- Audio יש להוסיף כ- Content ואז לסמנם כ- Copy if newer.
 
imageimage
 
כדי של- Agent יהיה גישה לקבצ האודיו, העתקתי אותם ל- Isolated Storage עם הפעלת האפליקציה המרכזית בעזרת מחלקת עזר:
 
Code Snippet
  1. private void Application_Launching(object sender, LaunchingEventArgs e)
  2. {
  3.     IsolatedStorageHelper.CopyFile("Audio", "Kalimba.mp3", "Maid with the Flaxen Hair.mp3", "Sleep Away.mp3");
  4. }
 
כעת, באפליקציה המרכזית יש לבצע 3 פעולות:
  1. להרשם לאירוע BackgroundAudioPlayer.PlayStateChanged.
  2. לעדכן את ממשק המשתמש עם נתוני האודיו החדשים בעת הפעלת האירוע.
  3. לעדכן את ממשק המשתמש עם נתוני האודיו החדשים בעת העלייה.
  4. לתפעל את BackgroundAudoPlayer בהתאמה.

Code Snippet
  1. public partial class MainPage : PhoneApplicationPage
  2. {
  3.     // Constructor
  4.     public MainPage()
  5.     {
  6.         InitializeComponent();
  8.         BackgroundAudioPlayer.Instance.PlayStateChanged += BackgroundAudioPlayer_PlayStateChanged;
  9.     }
  11.     protected override void OnNavigatedTo(NavigationEventArgs e)
  12.     {
  13.         if (BackgroundAudioPlayer.Instance.PlayerState == PlayState.Playing)
  14.         {
  15.             buttonPlay.Content = "Pause";
  16.             UpdateTrackInfo();
  17.         }
  18.         else
  19.         {
  20.             buttonPlay.Content = "Play";
  21.             UpdateTrackInfo(true);                
  22.         }
  23.     }        
  25.     private void BackgroundAudioPlayer_PlayStateChanged(object sender, EventArgs e)
  26.     {
  27.         switch (BackgroundAudioPlayer.Instance.PlayerState)
  28.         {
  29.             case PlayState.Playing:
  30.                 buttonPlay.Content = "Pause";
  31.                 break;
  33.             case PlayState.Paused:
  34.             case PlayState.Stopped:
  35.                 buttonPlay.Content = "Play";
  36.                 break;
  37.         }
  39.         if (BackgroundAudioPlayer.Instance.Track != null)
  40.         {
  41.             UpdateTrackInfo();
  42.         }
  43.     }
  45.     private void UpdateTrackInfo(bool reset = false)
  46.     {
  47.         if (reset)
  48.         {
  49.             imageAlbumArt.Source = null;
  50.             textBlockCurrentTitle.Text = string.Empty;
  51.             textBlockCurrentArtist.Text = string.Empty;
  52.             textBlockCurrentAlbum.Text = string.Empty;
  53.         }
  54.         else
  55.         {
  56.             imageAlbumArt.Source = new BitmapImage(BackgroundAudioPlayer.Instance.Track.AlbumArt);
  57.             textBlockCurrentTitle.Text = BackgroundAudioPlayer.Instance.Track.Title;
  58.             textBlockCurrentArtist.Text = BackgroundAudioPlayer.Instance.Track.Artist;
  59.             textBlockCurrentAlbum.Text = BackgroundAudioPlayer.Instance.Track.Album;
  60.         }
  61.     }
  63.     private void buttonPrev_Click(object sender, RoutedEventArgs e)
  64.     {
  65.         BackgroundAudioPlayer.Instance.SkipPrevious();
  66.     }
  68.     private void buttonPlay_Click(object sender, RoutedEventArgs e)
  69.     {
  70.         if (BackgroundAudioPlayer.Instance.PlayerState == PlayState.Playing)
  71.         {
  72.             BackgroundAudioPlayer.Instance.Pause();
  73.         }
  74.         else
  75.         {
  76.             BackgroundAudioPlayer.Instance.Play();
  77.         }
  78.     }
  80.     private void buttonNext_Click(object sender, RoutedEventArgs e)
  81.     {
  82.         BackgroundAudioPlayer.Instance.SkipNext();
  83.     }
  84. }
 
לפני שמורידים את הדוגמה, אציין שלא העליתי את קבצי ה- Audio בשל גודלם. ניתן למצוא את שלושת הקבצים בכל Windows 7 תיקיית Audio משותפת.
 
מה בפוסט הבא?
 
Published Saturday, July 02, 2011 11:42 PM by Tomer Shamam
תגים:, , , ,

Comments

No Comments

Leave a Comment

(required) 
(required) 
(optional)
(required) 

Enter the numbers above:

התוכן המופיע באתר זה הינו תוכן גולשים. התוכן אינו מטעם או בשליטת/פיקוח מיקרוסופט והיא אינה אחראית לו בכל צורה או אופן
תנאי שימוש |סימנים מסחריים |הצהרת פרטיות
Powered by Community Server (Commercial Edition), by Telligent Systems