‫Google משתמשת בטכנולוגיית AI כדי לתרגם תוכן לשפה המועדפת עליך. בתרגומים כאלו עשויות להיות שגיאות.

מחליף פלט

החל מ-Android 13, מתג הפלט הוא תכונה של Cast SDK שמאפשרת מעבר חלק בין הפעלה מקומית להפעלה מרחוק של תוכן. המטרה היא לעזור לאפליקציות השולחות לשלוט בקלות ובמהירות במקום שבו התוכן מופעל. מתג המעבר למכשיר אחר משתמש בספרייה MediaRouter כדי להעביר את הפעלת התוכן בין הרמקול של הטלפון, מכשירי Bluetooth מותאמים ומכשירים מרוחקים שתומכים ב-Cast. אפשר לחלק את תרחישי השימוש לתרחישים הבאים:

ממקומי למרוחק
מרחוק למקומי
מרחוק אל מרחוק

כדי לראות איך מטמיעים את מתג הפלט באפליקציה, אתם יכולים להוריד את האפליקציה לדוגמה CastVideos-android ולהשתמש בה.

כדי לתמוך בהעברה ממכשיר מקומי למכשיר מרוחק, ממכשיר מרוחק למכשיר מקומי וממכשיר מרוחק למכשיר מרוחק, צריך להפעיל את מתג הפלט לפי השלבים שמפורטים במדריך הזה. אין צורך לבצע פעולות נוספות כדי לתמוך בהעברה בין הרמקולים של המכשיר המקומי לבין מכשירי Bluetooth מותאמים.

ממשק המשתמש של מתג מעבר למכשיר אחר

במתג הפלט מוצגים המכשירים המקומיים והמכשירים שמחוברים לרשת אחרת שזמינים, וגם המצבים הנוכחיים של המכשירים, כולל אם המכשיר נבחר, אם הוא מתחבר ורמת עוצמת הקול הנוכחית. אם יש מכשירים אחרים בנוסף למכשיר הנוכחי, לחיצה על מכשיר אחר מאפשרת להעביר את הפעלת המדיה למכשיר שנבחר.

בעיות מוכרות

הפעלות מדיה שנוצרו להפעלה מקומית ייסגרו וייווצרו מחדש כשעוברים להתראה של Cast SDK.

נקודות כניסה

התראת מדיה

אם אפליקציה מפרסמת התראת מדיה עם MediaSession להפעלה מקומית, בפינה השמאלית העליונה של התראת המדיה מוצג צ'יפ של התראה עם שם המכשיר (למשל, הרמקול של הטלפון) שבו התוכן מופעל כרגע. לחיצה על הצ'יפ של ההתראה פותחת את ממשק המשתמש של המערכת בתיבת הדו-שיח של מתג הפלט.

הגדרות עוצמת הקול

אפשר להפעיל את ממשק המשתמש של תיבת הדו-שיח של מתג הפלט גם על ידי לחיצה על כפתורי עוצמת הקול הפיזיים במכשיר, לחיצה על סמל ההגדרות בתחתית ולחיצה על הטקסט "הפעלת <שם האפליקציה> ב <מכשיר Cast>".

סיכום השלבים

דרישות מוקדמות

מעבירים את אפליקציית Android הקיימת ל-AndroidX.
מעדכנים את build.gradle של האפליקציה כדי להשתמש בגרסה המינימלית הנדרשת של Android Sender SDK למתג הפלט:
```
dependencies {
  ...
  implementation 'com.google.android.gms:play-services-cast-framework:21.2.0'
  ...
}
```
האפליקציה תומכת בהתראות מדיה.
מכשיר עם Android 13.

הגדרת התראות מדיה

כדי להשתמש במתג הפלט, אפליקציות אודיו ווידאו צריכות ליצור התראת מדיה כדי להציג את סטטוס ההפעלה ואת אמצעי הבקרה של המדיה להפעלה מקומית. כדי לעשות את זה, צריך ליצור MediaSession, להגדיר את MediaStyle עם הטוקן של MediaSession ולהגדיר את ממשק השליטה במדיה בהתראה.

אם אתם לא משתמשים כרגע ב-MediaStyle וב-MediaSession, קטע הקוד הבא מראה איך להגדיר אותם. יש גם מדריכים להגדרת קריאות חוזרות (callbacks) של סשן מדיה לאפליקציות אודיו ווידאו:

Kotlin

// Create a media session. NotificationCompat.MediaStyle
// PlayerService is your own Service or Activity responsible for media playback.
val mediaSession = MediaSessionCompat(this, "PlayerService")

// Create a MediaStyle object and supply your media session token to it.
val mediaStyle = Notification.MediaStyle().setMediaSession(mediaSession.sessionToken)

// Create a Notification which is styled by your MediaStyle object.
// This connects your media session to the media controls.
// Don't forget to include a small icon.
val notification = Notification.Builder(this@PlayerService, CHANNEL_ID)
    .setStyle(mediaStyle)
    .setSmallIcon(R.drawable.ic_app_logo)
    .build()

// Specify any actions which your users can perform, such as pausing and skipping to the next track.
val pauseAction: Notification.Action = Notification.Action.Builder(
        pauseIcon, "Pause", pauseIntent
    ).build()
notification.addAction(pauseAction)

Java

if (android.os.Build.VERSION.SDK_INT >= android.os.Build.VERSION_CODES.O) {
    // Create a media session. NotificationCompat.MediaStyle
    // PlayerService is your own Service or Activity responsible for media playback.
    MediaSession mediaSession = new MediaSession(this, "PlayerService");

    // Create a MediaStyle object and supply your media session token to it.
    Notification.MediaStyle mediaStyle = new Notification.MediaStyle().setMediaSession(mediaSession.getSessionToken());

    // Specify any actions which your users can perform, such as pausing and skipping to the next track.
    Notification.Action pauseAction = Notification.Action.Builder(pauseIcon, "Pause", pauseIntent).build();

    // Create a Notification which is styled by your MediaStyle object.
    // This connects your media session to the media controls.
    // Don't forget to include a small icon.
    String CHANNEL_ID = "CHANNEL_ID";
    Notification notification = new Notification.Builder(this, CHANNEL_ID)
        .setStyle(mediaStyle)
        .setSmallIcon(R.drawable.ic_app_logo)
        .addAction(pauseAction)
        .build();
}

בנוסף, כדי לאכלס את ההתראה במידע על המדיה, צריך להוסיף את המטא-נתונים ומצב ההפעלה של המדיה אל MediaSession.

כדי להוסיף מטא-נתונים ל-MediaSession, משתמשים ב-setMetaData() ומספקים את כל הקבועים הרלוונטיים של MediaMetadata למדיה ב-MediaMetadataCompat.Builder().

Kotlin

mediaSession.setMetadata(MediaMetadataCompat.Builder()
    // Title
    .putString(MediaMetadata.METADATA_KEY_TITLE, currentTrack.title)

    // Artist
    // Could also be the channel name or TV series.
    .putString(MediaMetadata.METADATA_KEY_ARTIST, currentTrack.artist)

    // Album art
    // Could also be a screenshot or hero image for video content
    // The URI scheme needs to be "content", "file", or "android.resource".
    .putString(
        MediaMetadata.METADATA_KEY_ALBUM_ART_URI, currentTrack.albumArtUri)
    )

    // Duration
    // If duration isn't set, such as for live broadcasts, then the progress
    // indicator won't be shown on the seekbar.
    .putLong(MediaMetadata.METADATA_KEY_DURATION, currentTrack.duration)

    .build()
)

Java

if (android.os.Build.VERSION.SDK_INT >= android.os.Build.VERSION_CODES.O) {
    mediaSession.setMetadata(
        new MediaMetadataCompat.Builder()
        // Title
        .putString(MediaMetadata.METADATA_KEY_TITLE, currentTrack.title)

        // Artist
        // Could also be the channel name or TV series.
        .putString(MediaMetadata.METADATA_KEY_ARTIST, currentTrack.artist)

        // Album art
        // Could also be a screenshot or hero image for video content
        // The URI scheme needs to be "content", "file", or "android.resource".
        .putString(MediaMetadata.METADATA_KEY_ALBUM_ART_URI, currentTrack.albumArtUri)

        // Duration
        // If duration isn't set, such as for live broadcasts, then the progress
        // indicator won't be shown on the seekbar.
        .putLong(MediaMetadata.METADATA_KEY_DURATION, currentTrack.duration)

        .build()
    );
}

כדי להוסיף את מצב ההפעלה ל-MediaSession, משתמשים ב-setPlaybackState() ומספקים את כל הקבועים הרלוונטיים של PlaybackStateCompat למדיה ב-PlaybackStateCompat.Builder().

Kotlin

mediaSession.setPlaybackState(
    PlaybackStateCompat.Builder()
        .setState(
            PlaybackStateCompat.STATE_PLAYING,

            // Playback position
            // Used to update the elapsed time and the progress bar.
            mediaPlayer.currentPosition.toLong(),

            // Playback speed
            // Determines the rate at which the elapsed time changes.
            playbackSpeed
        )

        // isSeekable
        // Adding the SEEK_TO action indicates that seeking is supported
        // and makes the seekbar position marker draggable. If this is not
        // supplied seek will be disabled but progress will still be shown.
        .setActions(PlaybackStateCompat.ACTION_SEEK_TO)
        .build()
)

Java

if (android.os.Build.VERSION.SDK_INT >= android.os.Build.VERSION_CODES.O) {
    mediaSession.setPlaybackState(
        new PlaybackStateCompat.Builder()
            .setState(
                 PlaybackStateCompat.STATE_PLAYING,

                // Playback position
                // Used to update the elapsed time and the progress bar.
                mediaPlayer.currentPosition.toLong(),

                // Playback speed
                // Determines the rate at which the elapsed time changes.
                playbackSpeed
            )

        // isSeekable
        // Adding the SEEK_TO action indicates that seeking is supported
        // and makes the seekbar position marker draggable. If this is not
        // supplied seek will be disabled but progress will still be shown.
        .setActions(PlaybackStateCompat.ACTION_SEEK_TO)
        .build()
    );
}

אופן הפעולה של התראות באפליקציית הווידאו

באפליקציות וידאו או אודיו שלא תומכות בהפעלה מקומית ברקע, צריך להגדיר התנהגות ספציפית להתראות מדיה כדי למנוע בעיות בשליחת פקודות מדיה במצבים שבהם ההפעלה לא נתמכת:

מפרסמים את ההתראה על המדיה כשמפעילים מדיה באופן מקומי והאפליקציה פועלת בחזית.
להשהות את ההפעלה המקומית ולסגור את ההתראה כשהאפליקציה פועלת ברקע.
כשהאפליקציה חוזרת לחזית, ההפעלה המקומית אמורה להתחדש וההתראה אמורה להתפרסם מחדש.

הפעלת מתג המעבר למכשיר אחר בקובץ AndroidManifest.xml

כדי להפעיל את מתג המעבר למכשיר אחר, צריך להוסיף את MediaTransferReceiver ל-AndroidManifest.xml של האפליקציה. אם היא לא מופעלת, התכונה לא תופעל וגם ה-feature flag של remote-to-local לא יהיה חוקי.

<application>
    ...
    <receiver
         android:name="androidx.mediarouter.media.MediaTransferReceiver"
         android:exported="true">
    </receiver>
    ...
</application>

MediaTransferReceiver הוא מקלט שידור שמאפשר להעביר מדיה בין מכשירים עם ממשק משתמש של המערכת. מידע נוסף זמין בחומר העזר בנושא MediaTransferReceiver.

ממקומי למרוחק

כשהמשתמש מעביר את ההפעלה ממכשיר מקומי למכשיר מרוחק, Cast SDK יתחיל את הסשן של Cast באופן אוטומטי. עם זאת, האפליקציות צריכות לטפל במעבר מהפעלה מקומית להפעלה מרחוק, למשל להפסיק את ההפעלה המקומית ולטעון את המדיה במכשיר Cast. האפליקציות צריכות להאזין ל-Cast SessionManagerListener, באמצעות פונקציות ה-callback onSessionStarted() ו- onSessionEnded() , ולטפל בפעולה כשהן מקבלות את פונקציות ה-callback של Cast SessionManager . האפליקציות צריכות לוודא שהקריאות החוזרות האלה עדיין פעילות כשתיבת הדו-שיח של מתג הפלט נפתחת והאפליקציה לא פועלת בחזית.

עדכון של SessionManagerListener להפעלת Cast ברקע

הגרסה הקודמת של Cast כבר תומכת בהעברה ממכשיר מקומי למכשיר מרוחק כשהאפליקציה פועלת בחזית. חוויית Cast טיפוסית מתחילה כשהמשתמשים לוחצים על סמל Cast באפליקציה ובוחרים מכשיר להפעלת מדיה בסטרימינג. במקרה כזה, האפליקציה צריכה להירשם ל-SessionManagerListener ב-onCreate() או ב-onStart(), ולבטל את הרישום של ה-listener ב-onStop() או ב-onDestroy() של הפעילות באפליקציה.

בגרסה החדשה של העברה באמצעות מתג הפלט, אפליקציות יכולות להתחיל להעביר כשהן פועלות ברקע. האפשרות הזו שימושית במיוחד לאפליקציות אודיו שמפרסמות התראות כשהן פועלות ברקע. אפליקציות יכולות לרשום את המאזינים של SessionManager ב-onCreate() של השירות, ולבטל את הרישום ב-onDestroy() של השירות. האפליקציות צריכות תמיד לקבל את הקריאות החוזרות (callbacks) מהמכשיר המקומי למכשיר המרוחק (כמו onSessionStarted) כשהאפליקציה פועלת ברקע.

אם האפליקציה משתמשת ב-MediaBrowserService, מומלץ לרשום שם את SessionManagerListener.

Kotlin

class MyService : Service() {
    private var castContext: CastContext? = null
    protected fun onCreate() {
        castContext = CastContext.getSharedInstance(this)
        castContext
            .getSessionManager()
            .addSessionManagerListener(sessionManagerListener, CastSession::class.java)
    }

    protected fun onDestroy() {
        if (castContext != null) {
            castContext
                .getSessionManager()
                .removeSessionManagerListener(sessionManagerListener, CastSession::class.java)
        }
    }
}

Java

public class MyService extends Service {
  private CastContext castContext;

  @Override
  protected void onCreate() {
     castContext = CastContext.getSharedInstance(this);
     castContext
        .getSessionManager()
        .addSessionManagerListener(sessionManagerListener, CastSession.class);
  }

  @Override
  protected void onDestroy() {
    if (castContext != null) {
       castContext
          .getSessionManager()
          .removeSessionManagerListener(sessionManagerListener, CastSession.class);
    }
  }
}

בעדכון הזה, העברה ממכשיר מקומי למכשיר מרוחק פועלת כמו העברה רגילה כשהאפליקציה פועלת ברקע, ולא נדרשת עבודה נוספת כדי לעבור ממכשירי Bluetooth למכשירי Cast.

ממרוחק למקומי

מתג המעבר למכשיר אחר מאפשר לעבור מהפעלה מרחוק לרמקול של הטלפון או למכשיר Bluetooth מקומי. כדי להפעיל את האפשרות הזו, צריך להגדיר את הדגל setRemoteToLocalEnabled לערך true ב-CastOptions.

במקרים שבהם המכשיר השולח הנוכחי מצטרף לסשן קיים עם כמה שולחים, והאפליקציה צריכה לבדוק אם מותר להעביר את המדיה הנוכחית באופן מקומי, האפליקציות צריכות להשתמש בקריאה החוזרת (callback) onTransferred של SessionTransferCallback כדי לבדוק את SessionState.

מגדירים את הדגל setRemoteToLocalEnabled

CastOptions.Builder מספק setRemoteToLocalEnabled כדי להציג או להסתיר את הרמקול של הטלפון ומכשירי Bluetooth מקומיים כיעדים להעברה בתיבת הדו-שיח של מתג הפלט כשיש סשן העברה פעיל.

Kotlin

class CastOptionsProvider : OptionsProvider {
    fun getCastOptions(context: Context?): CastOptions {
        ...
        return Builder()
            ...
            .setRemoteToLocalEnabled(true)
            .build()
    }
}

Java

public class CastOptionsProvider implements OptionsProvider {
    @Override
    public CastOptions getCastOptions(Context context) {
        ...
        return new CastOptions.Builder()
            ...
            .setRemoteToLocalEnabled(true)
            .build()
  }
}

המשך ההפעלה באופן מקומי

אפליקציות שתומכות בהעברה מרחוק למכשיר המקומי צריכות לרשום את SessionTransferCallback כדי לקבל התראה כשהאירוע מתרחש, כדי שהן יוכלו לבדוק אם צריך לאפשר את העברת המדיה ולהמשיך את ההפעלה באופן מקומי.

CastContext#addSessionTransferCallback(SessionTransferCallback) מאפשר לאפליקציה לרשום את SessionTransferCallback שלה ולהאזין לקריאות חוזרות (callbacks) של onTransferred ו-onTransferFailed כששולח מועבר להפעלה מקומית.

אחרי שהאפליקציה תבטל את הרישום של SessionTransferCallback, היא לא תקבל יותר SessionTransferCallback.

ה-SessionTransferCallback הוא הרחבה של הקריאות החוזרות הקיימות של SessionManagerListener, והוא מופעל אחרי ש-onSessionEnded מופעל. הסדר של הקריאות החוזרות מרחוק למקומי הוא:

onTransferring
onSessionEnding
onSessionEnded
onTransferred

מכיוון שאפשר לפתוח את מתג הפלט באמצעות הצ'יפ של ההתראה על המדיה כשהאפליקציה פועלת ברקע ומפעילה Cast, האפליקציות צריכות לטפל בהעברה למכשיר המקומי באופן שונה, בהתאם לתמיכה שלהן בהפעלה ברקע. אם ההעברה נכשלה, onTransferFailed יופעל בכל פעם שהשגיאה תתרחש.

אפליקציות שתומכות בהפעלה ברקע

באפליקציות שתומכות בהפעלה ברקע (בדרך כלל אפליקציות אודיו), מומלץ להשתמש ב-Service (לדוגמה MediaBrowserService). השירותים צריכים להאזין לקריאה החוזרת (callback) של onTransferred ולהמשיך את ההפעלה באופן מקומי כשהאפליקציה פועלת בחזית או ברקע.

Kotlin

class MyService : Service() {
    private var castContext: CastContext? = null
    private var sessionTransferCallback: SessionTransferCallback? = null
    protected fun onCreate() {
        castContext = CastContext.getSharedInstance(this)
        castContext.getSessionManager()
                   .addSessionManagerListener(sessionManagerListener, CastSession::class.java)
        sessionTransferCallback = MySessionTransferCallback()
        castContext.addSessionTransferCallback(sessionTransferCallback)
    }

    protected fun onDestroy() {
        if (castContext != null) {
            castContext.getSessionManager()
                       .removeSessionManagerListener(sessionManagerListener, CastSession::class.java)
            if (sessionTransferCallback != null) {
                castContext.removeSessionTransferCallback(sessionTransferCallback)
            }
        }
    }

    class MySessionTransferCallback : SessionTransferCallback() {
        fun onTransferring(@SessionTransferCallback.TransferType transferType: Int) {
            // Perform necessary steps prior to onTransferred
        }

        fun onTransferred(@SessionTransferCallback.TransferType transferType: Int,
                          sessionState: SessionState?) {
            if (transferType == SessionTransferCallback.TRANSFER_TYPE_FROM_REMOTE_TO_LOCAL) {
                // Remote stream is transferred to the local device.
                // Retrieve information from the SessionState to continue playback on the local player.
            }
        }

        fun onTransferFailed(@SessionTransferCallback.TransferType transferType: Int,
                             @SessionTransferCallback.TransferFailedReason transferFailedReason: Int) {
            // Handle transfer failure.
        }
    }
}

Java

public class MyService extends Service {
    private CastContext castContext;
    private SessionTransferCallback sessionTransferCallback;

    @Override
    protected void onCreate() {
        castContext = CastContext.getSharedInstance(this);
        castContext.getSessionManager()
                   .addSessionManagerListener(sessionManagerListener, CastSession.class);
        sessionTransferCallback = new MySessionTransferCallback();
        castContext.addSessionTransferCallback(sessionTransferCallback);
    }

    @Override
    protected void onDestroy() {
        if (castContext != null) {
            castContext.getSessionManager()
                       .removeSessionManagerListener(sessionManagerListener, CastSession.class);
            if (sessionTransferCallback != null) {
                castContext.removeSessionTransferCallback(sessionTransferCallback);
            }
        }
    }

    public static class MySessionTransferCallback extends SessionTransferCallback {
        public MySessionTransferCallback() {}

        @Override
        public void onTransferring(@SessionTransferCallback.TransferType int transferType) {
            // Perform necessary steps prior to onTransferred
        }

        @Override
        public void onTransferred(@SessionTransferCallback.TransferType int transferType,
                                  SessionState sessionState) {
            if (transferType==SessionTransferCallback.TRANSFER_TYPE_FROM_REMOTE_TO_LOCAL) {
                // Remote stream is transferred to the local device.
                // Retrieve information from the SessionState to continue playback on the local player.
            }
        }

        @Override
        public void onTransferFailed(@SessionTransferCallback.TransferType int transferType,
                                     @SessionTransferCallback.TransferFailedReason int transferFailedReason) {
            // Handle transfer failure.
        }
    }
}

אפליקציות שלא תומכות בהפעלה ברקע

באפליקציות שלא תומכות בהפעלה ברקע (בדרך כלל אפליקציות וידאו), מומלץ להאזין לקריאה החוזרת (callback) של onTransferred ולהמשיך את ההפעלה באופן מקומי אם האפליקציה פועלת בחזית.

אם האפליקציה פועלת ברקע, היא צריכה להשהות את ההפעלה ולשמור את המידע הנדרש מ-SessionState (לדוגמה, מטא-נתונים של המדיה ומיקום ההפעלה). כשהאפליקציה עוברת מהרקע לחזית, ההפעלה המקומית אמורה להימשך עם המידע שנשמר.

Kotlin

class MyActivity : AppCompatActivity() {
    private var castContext: CastContext? = null
    private var sessionTransferCallback: SessionTransferCallback? = null
    protected fun onCreate() {
        castContext = CastContext.getSharedInstance(this)
        castContext.getSessionManager()
                   .addSessionManagerListener(sessionManagerListener, CastSession::class.java)
        sessionTransferCallback = MySessionTransferCallback()
        castContext.addSessionTransferCallback(sessionTransferCallback)
    }

    protected fun onDestroy() {
        if (castContext != null) {
            castContext.getSessionManager()
                       .removeSessionManagerListener(sessionManagerListener, CastSession::class.java)
            if (sessionTransferCallback != null) {
                castContext.removeSessionTransferCallback(sessionTransferCallback)
            }
        }
    }

    class MySessionTransferCallback : SessionTransferCallback() {
        fun onTransferring(@SessionTransferCallback.TransferType transferType: Int) {
            // Perform necessary steps prior to onTransferred
        }

        fun onTransferred(@SessionTransferCallback.TransferType transferType: Int,
                          sessionState: SessionState?) {
            if (transferType == SessionTransferCallback.TRANSFER_TYPE_FROM_REMOTE_TO_LOCAL) {
                // Remote stream is transferred to the local device.

                // Retrieve information from the SessionState to continue playback on the local player.
            }
        }

        fun onTransferFailed(@SessionTransferCallback.TransferType transferType: Int,
                             @SessionTransferCallback.TransferFailedReason transferFailedReason: Int) {
            // Handle transfer failure.
        }
    }
}

Java

public class MyActivity extends AppCompatActivity {
  private CastContext castContext;
  private SessionTransferCallback sessionTransferCallback;

  @Override
  protected void onCreate() {
     castContext = CastContext.getSharedInstance(this);
     castContext
        .getSessionManager()
        .addSessionManagerListener(sessionManagerListener, CastSession.class);
     sessionTransferCallback = new MySessionTransferCallback();
     castContext.addSessionTransferCallback(sessionTransferCallback);
  }

  @Override
  protected void onDestroy() {
    if (castContext != null) {
       castContext
          .getSessionManager()
          .removeSessionManagerListener(sessionManagerListener, CastSession.class);
      if (sessionTransferCallback != null) {
         castContext.removeSessionTransferCallback(sessionTransferCallback);
      }
    }
  }

  public static class MySessionTransferCallback extends SessionTransferCallback {
    public MySessionTransferCallback() {}

    @Override
    public void onTransferring(@SessionTransferCallback.TransferType int transferType) {
        // Perform necessary steps prior to onTransferred
    }

    @Override
    public void onTransferred(@SessionTransferCallback.TransferType int transferType,
                               SessionState sessionState) {
      if (transferType==SessionTransferCallback.TRANSFER_TYPE_FROM_REMOTE_TO_LOCAL) {
        // Remote stream is transferred to the local device.

        // Retrieve information from the SessionState to continue playback on the local player.
      }
    }

    @Override
    public void onTransferFailed(@SessionTransferCallback.TransferType int transferType,
                                 @SessionTransferCallback.TransferFailedReason int transferFailedReason) {
      // Handle transfer failure.
    }
  }
}

ממכשיר מרוחק למכשיר מרוחק

מתג המעבר למכשיר אחר תומך באפשרות להרחיב את ההפעלה למספר מכשירי רמקולים שתומכים ב-Cast, באפליקציות אודיו שמשתמשות בהוספת רמקולים.

אפליקציות אודיו הן אפליקציות שתומכות ב-Google Cast for Audio בהגדרות של אפליקציית המקלט במסוף המפתחים של Google Cast SDK.

הוספת רמקולים

אפליקציות אודיו שמשתמשות במתג הפלט יכולות להרחיב את האודיו למספר מכשירי רמקולים שתומכים ב-Cast במהלך סשן Cast באמצעות הרחבת סטרימינג.

התכונה הזו נתמכת בפלטפורמת Cast ולא נדרשים שינויים נוספים אם האפליקציה משתמשת בממשק המשתמש שמוגדר כברירת מחדל. אם משתמשים בממשק משתמש מותאם אישית, האפליקציה צריכה לעדכן את ממשק המשתמש כדי לציין שהאפליקציה מפעילה Cast לקבוצה.

כדי לקבל את השם החדש של הקבוצה המורחבת במהלך הוספת רמקולים, רושמים Cast.Listener באמצעות CastSession#addCastListener. ואז מתקשרים אל CastSession#getCastDevice() במהלך השיחה החוזרת של onDeviceNameChanged.

Kotlin

class MyActivity : Activity() {
    private var mCastSession: CastSession? = null
    private lateinit var mCastContext: CastContext
    private lateinit var mSessionManager: SessionManager
    private val mSessionManagerListener: SessionManagerListener<CastSession> =
        SessionManagerListenerImpl()
    private val mCastListener = CastListener()

    private inner class SessionManagerListenerImpl : SessionManagerListener<CastSession?> {
        override fun onSessionStarting(session: CastSession?) {}

        override fun onSessionStarted(session: CastSession?, sessionId: String) {
            addCastListener(session)
        }

        override fun onSessionStartFailed(session: CastSession?, error: Int) {}

        override fun onSessionSuspended(session: CastSession?, reason Int) {
            removeCastListener()
        }

        override fun onSessionResuming(session: CastSession?, sessionId: String) {}

        override fun onSessionResumed(session: CastSession?, wasSuspended: Boolean) {
            addCastListener(session)
        }

        override fun onSessionResumeFailed(session: CastSession?, error: Int) {}

        override fun onSessionEnding(session: CastSession?) {}

        override fun onSessionEnded(session: CastSession?, error: Int) {
            removeCastListener()
        }
    }

    private inner class CastListener : Cast.Listener() {
        override fun onDeviceNameChanged() {
            mCastSession?.let {
                val castDevice = it.castDevice
                val deviceName = castDevice.friendlyName
                // Update UIs with the new cast device name.
            }
        }
    }

    private fun addCastListener(castSession: CastSession) {
        mCastSession = castSession
        mCastSession?.addCastListener(mCastListener)
    }

    private fun removeCastListener() {
        mCastSession?.removeCastListener(mCastListener)
    }

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        mCastContext = CastContext.getSharedInstance(this)
        mSessionManager = mCastContext.sessionManager
        mSessionManager.addSessionManagerListener(mSessionManagerListener, CastSession::class.java)
    }

    override fun onDestroy() {
        super.onDestroy()
        mSessionManager.removeSessionManagerListener(mSessionManagerListener, CastSession::class.java)
    }
}

Java

public class MyActivity extends Activity {
    private CastContext mCastContext;
    private CastSession mCastSession;
    private SessionManager mSessionManager;
    private SessionManagerListener<CastSession> mSessionManagerListener =
            new SessionManagerListenerImpl();
    private Cast.Listener mCastListener = new CastListener();

    private class SessionManagerListenerImpl implements SessionManagerListener<CastSession> {
        @Override
        public void onSessionStarting(CastSession session) {}
        @Override
        public void onSessionStarted(CastSession session, String sessionId) {
            addCastListener(session);
        }
        @Override
        public void onSessionStartFailed(CastSession session, int error) {}
        @Override
        public void onSessionSuspended(CastSession session, int reason) {
            removeCastListener();
        }
        @Override
        public void onSessionResuming(CastSession session, String sessionId) {}
        @Override
        public void onSessionResumed(CastSession session, boolean wasSuspended) {
            addCastListener(session);
        }
        @Override
        public void onSessionResumeFailed(CastSession session, int error) {}
        @Override
        public void onSessionEnding(CastSession session) {}
        @Override
        public void onSessionEnded(CastSession session, int error) {
            removeCastListener();
        }
    }

    private class CastListener extends Cast.Listener {
         @Override
         public void onDeviceNameChanged() {
             if (mCastSession == null) {
                 return;
             }
             CastDevice castDevice = mCastSession.getCastDevice();
             String deviceName = castDevice.getFriendlyName();
             // Update UIs with the new cast device name.
         }
    }

    private void addCastListener(CastSession castSession) {
        mCastSession = castSession;
        mCastSession.addCastListener(mCastListener);
    }

    private void removeCastListener() {
        if (mCastSession != null) {
            mCastSession.removeCastListener(mCastListener);
        }
    }

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        mCastContext = CastContext.getSharedInstance(this);
        mSessionManager = mCastContext.getSessionManager();
        mSessionManager.addSessionManagerListener(mSessionManagerListener, CastSession.class);
    }

    @Override
    protected void onDestroy() {
        super.onDestroy();
        mSessionManager.removeSessionManagerListener(mSessionManagerListener, CastSession.class);
    }
}

בדיקה של שלט רחוק לשלט רחוק

כדי לבדוק את התכונה:

אתם יכולים להעביר את התוכן למכשיר שתומך ב-Cast באמצעות העברה רגילה או באמצעות העברה ממכשיר מקומי למכשיר מרוחק.
פותחים את מתג הפלט באמצעות אחת מנקודות הכניסה.
לוחצים על מכשיר אחר שתומך ב-Cast, ואפליקציות האודיו ירחיבו את התוכן למכשיר הנוסף וייצרו קבוצה דינמית.
לוחצים שוב על המכשיר שתומך ב-Cast כדי להסיר אותו מהקבוצה הדינמית.

כוונת הצטרפות

תכונות נוספות

מחליף פלט קל לארגן דפים בעזרת אוספים אפשר לשמור ולסווג תוכן על סמך ההעדפות שלך.

ממשק המשתמש של מתג מעבר למכשיר אחר

בעיות מוכרות

נקודות כניסה

התראת מדיה

הגדרות עוצמת הקול

סיכום השלבים

דרישות מוקדמות

הגדרת התראות מדיה

אופן הפעולה של התראות באפליקציית הווידאו

הפעלת מתג המעבר למכשיר אחר בקובץ AndroidManifest.xml

ממקומי למרוחק

עדכון של SessionManagerListener להפעלת Cast ברקע

ממרוחק למקומי

מגדירים את הדגל setRemoteToLocalEnabled

המשך ההפעלה באופן מקומי

אפליקציות שתומכות בהפעלה ברקע

אפליקציות שלא תומכות בהפעלה ברקע

ממכשיר מרוחק למכשיר מרוחק

הוספת רמקולים

בדיקה של שלט רחוק לשלט רחוק

מחליף פלט