Sessions API

デバイス検出 API とセキュア接続 API をベースにして、 Sessions API の強力な抽象化により、シームレスなクロスデバイス エクスペリエンスを実現 体験できますセッションとは、アプリケーションのユーザー エクスペリエンスであり、 デバイス間で転送、共有されます。

Sessions API は、個人および法人の セッション転送とセッション共有のユースケースに代表されるエクスペリエンス できます。次の図は、セッションの概要を示しています。

図 1. セッションの図。

セッションを作成して転送する

Sessions API は発信元デバイスと受信デバイスを区別します。送信元デバイスがセッションを作成し、 別のデバイスに接続することもできます発信元デバイスのユーザー システム ダイアログに表示されるリストからデバイスを選択します。ユーザーが 受信デバイスを選択すると、発信元のセッションが転送されて削除されます。 受信します。

セッションを転送するには、まず以下を使用してセッションを作成する必要があります parameters:

  • アプリケーション セッション タグ - アプリケーション セッション タグを区別できるようにする識別子 アプリの複数のセッション間の

次に、以下のパラメータを使用して転送を開始します。

  • セッションを処理できるデバイスをフィルタするための DeviceFilter
  • OriginatingSessionStateCallback を実装するコールバック オブジェクト

送信元のデバイスで、次の例を使用してセッションを作成します。

KotlinJava
private val HELLO_WORLD_TRANSFER_ACTION = "hello_world_transfer"
private lateinit var originatingSession: OriginatingSession
private lateinit var sessions: Sessions

override fun onCreate(savedInstanceState: Bundle?) {
 
super.onCreate(savedInstanceState)
  sessions
= Sessions.create(context = this)
}

suspend fun transferSession() {
 
val sessionId =
    sessions
.createSession(
     
ApplicationSessionTag("hello_world_transfer"),
   
)
  originatingSession
=
    sessions
.transferSession(
      sessionId
,
     
StartComponentRequest.Builder()
       
.setAction(HELLO_WORLD_TRANSFER_ACTION)
       
.setReason("Transfer reason here")
       
.build(),
      emptyList
(),
     
HelloWorldTransferSessionStateCallback()
   
)
}
private static final String HELLO_WORLD_TRANSFER_ACTION = "hello_world_transfer";
private OriginatingSession originatingSession;
private Sessions sessions;

@Override
public void onCreate(@Nullable Bundle savedInstanceState) {
 
super.onCreate(savedInstanceState);
  sessions
= Sessions.create(/* context= */ this);
}

public void transferSession() {
 
SessionId sessionId = sessions.createSession(new ApplicationSessionTag("hello_world_transfer"));
 
ListenableFuture<OriginatingSession> originatingSessionFuture =
      sessions
.transferSessionFuture(
          sessionId
,
         
new StartComponentRequest.Builder()
             
.setAction(HELLO_WORLD_TRANSFER_ACTION)
             
.setReason("Transfer reason here")
             
.build(),
         
Collections.emptyList(),
         
new HelloWorldTransferSessionStateCallback());
 
Futures.addCallback(
      originatingSessionFuture
,
     
new FutureCallback<>() {
       
@Override
       
public void onSuccess(OriginatingSession result) {
         
// Do nothing, handled in HelloWorldTransferSessionStateCallback
          originatingSession
= result;
       
}

       
@Override
       
public void onFailure(Throwable t) {
         
Log.d(TAG, "onFailure called for transferSessionFuture", t);
       
}
     
},
      mainExecutor
);
}

次に、発信元デバイスでのセッション コールバックを定義します。

KotlinJava
private inner class HelloWorldTransferSessionStateCallback : OriginatingSessionStateCallback {
 
override fun onConnected(sessionId: SessionId) {
   
val startupRemoteConnection = originatingSession.getStartupRemoteConnection()
    lifecycleScope
.launchWhenResumed {
      startupRemoteConnection
.send("hello, world".toByteArray(UTF_8))
      startupRemoteConnection
.registerReceiver(
       
object : SessionConnectionReceiver {
         
override fun onMessageReceived(participant: SessionParticipant, payload: ByteArray) {
           
val ok = payload.contentEquals("ok".toByteArray(UTF_8))
           
Log.d(TAG, "Session transfer initialized. ok=$ok")
         
}
       
}
     
)
   
}
 
}

 
override fun onSessionTransferred(sessionId: SessionId) {
   
Log.d(TAG, "Transfer done.")
 
}

 
override fun onTransferFailure(sessionId: SessionId, exception: SessionException) {
   
// Handle error
 
}
}
private class HelloWorldTransferSessionStateCallback implements OriginatingSessionStateCallback {
 
@Override
 
public void onConnected(SessionId sessionId) {
   
SessionRemoteConnection startupRemoteConnection =
        originatingSession
.getStartupRemoteConnection();
   
Futures.addCallback(
        startupRemoteConnection
.sendFuture("hello, world".getBytes()),
       
new FutureCallback<>() {
         
@Override
         
public void onSuccess(Void result) {
           
Log.d(TAG, "Successfully sent initialization message");
         
}

         
@Override
         
public void onFailure(Throwable t) {
           
Log.d(TAG, "Failed to send initialization message", t);
         
}
       
},
        mainExecutor
);
 
}

 
@Override
 
public void onSessionTransferred(SessionId sessionId) {
   
Log.d(TAG, "Transfer done.");
 
}

 
@Override
 
public void onTransferFailure(SessionId sessionId, SessionException exception) {
   
// Handle error
 
}
}

セッション転送が開始されると、受信側デバイスがコールバックを受信 onNewIntent(intent: Intent) メソッド内。インテントデータには 必要ありません。

転送先のデバイスで移行を完了するには:

KotlinJava
private lateinit var sessions: Sessions

override fun onCreate(savedInstanceState: Bundle?) {
 
super.onCreate(savedInstanceState)
  sessions
= Sessions.create(context = this)
}

override fun onNewIntent(intent: Intent) {
 
super.onNewIntent(intent)
  lifecycleScope
.launchWhenResumed {
   
val receivingSession =
      sessions
.getReceivingSession(intent, HelloWorldReceivingSessionStateCallback())

   
// Get info from receiving device and init.
   
val startupRemoteConnection = receivingSession.getStartupRemoteConnection()

    startupRemoteConnection
.registerReceiver(
     
object : SessionConnectionReceiver {
       
override fun onMessageReceived(participant: SessionParticipant, payload: ByteArray) {
          lifecycleScope
.launchWhenResumed {
           
val transferInfo = String(payload)
            startupRemoteConnection
.send("ok".toByteArray(UTF_8))
           
// Complete transfer.
           
Log.d(TAG, "Transfer info: " + transferInfo)
            receivingSession
.onComplete()
         
}
       
}
     
}
   
)
 
}
}

private inner class HelloWorldReceivingSessionStateCallback : ReceivingSessionStateCallback {
 
override fun onTransferFailure(sessionId: SessionId, exception: SessionException) {
   
// Handle error
 
}
}
private Sessions sessions;

@Override
public void onCreate(@Nullable Bundle savedInstanceState) {
 
super.onCreate(savedInstanceState);
  sessions
= Sessions.create(/* context= */ this);
}

@Override
public void onNewIntent(Intent intent) {
 
super.onNewIntent(intent);
 
ListenableFuture<ReceivingSession> receivingSessionFuture =
      sessions
.getReceivingSessionFuture(intent, new HelloWorldReceivingSessionStateCallback());
 
ListenableFuture<Void> registerReceiverFuture =
     
Futures.transform(
          receivingSessionFuture
,
          receivingSession
-> {
           
SessionRemoteConnection startupRemoteConnection =
                receivingSession
.getStartupRemoteConnection();
           
SessionConnectionReceiver receiver =
               
(participant, payload) -> {
                 
Log.d(
                      TAG
,
                     
"Successfully received initialization message of size: " + payload.length);
                  applicationInitialization
(receivingSession, payload);
               
};
            startupRemoteConnection
.registerReceiver(receiver);
           
return null;
         
},
          mainExecutor
);
 
Futures.addCallback(
      registerReceiverFuture
,
     
new FutureCallback<Void>() {
       
@Override
       
public void onSuccess(Void unused) {
         
Log.d(TAG, "Connection receiver registerd successfully");
       
}

       
@Override
       
public void onFailure(Throwable t) {
         
Log.w(TAG, "Failed to register connection receiver", t);
       
}
     
},
      mainExecutor
);
}

private void applicationInitialization(ReceivingSession receivingSession, byte[] initMessage) {
 
ListenableFuture<SessionId> disconnectFuture =
     
Futures.transform(
          receivingSession
.onCompleteFuture(),
          sessionId
-> {
           
Log.d(TAG, "Succeeded to complete receive transfer for: " + sessionId);
           
return sessionId;
         
},
          mainExecutor
);
 
Futures.addCallback(
      disconnectFuture
,
     
new FutureCallback<SessionId>() {
       
@Override
       
public void onSuccess(SessionId result) {
         
Log.d(TAG, "Succeeded to remove the old session: " + result);
       
}

       
@Override
       
public void onFailure(Throwable t) {
         
Log.d(TAG, "Failed to remove the old session, which is now orphaned", t);
       
}
     
},
      mainExecutor
);
}

private static class HelloWorldReceivingSessionStateCallback
   
implements ReceivingSessionStateCallback {
 
@Override
 
public void onTransferFailure(SessionId sessionId, SessionException exception) {
   
// Handle error
 
}
}

これで、受信側デバイスでユーザー エクスペリエンスを続行できます。

セッションを共有する

セッションを共有すると、近くの人をグループに招待できます。 たとえば次のようなものです

  • 乗客として、友人の車に直接地図上の位置を共有する。
  • 日曜日のサイクリング ルートを、一緒に自転車に乗っている人と共有しましょう。
  • スマートフォンを回さずに、グループの料理の注文用に商品を集める。
  • みんなで視聴する次のテレビ番組について、グループで投票してください。

ユーザーが別のデバイスとのセッションの共有を選択すると、 デバイスが、セッションに参加できるデバイスと、 ユーザーが受信側デバイスを選択する。アプリケーションでは、プロンプトを使用して、 受信側デバイスを使用して、送信側デバイスからセッションに参加します。受信 デバイスにこのセッションとやり取りするためのセカンダリ セッションが与えられます。 接続されます。アプリでは、参加者をグループに追加すると、 継続して行われる共有セッションです。

セッションを共有するプロセスは、セッションの転送に似ていますが、 transferSession を呼び出す代わりに、shareSession を呼び出します。もう 1 つは、 セッション状態のコールバック メソッドが異なります。

KotlinJava
// Originating side.
private val HELLO_WORLD_SHARE_ACTION = "hello_world_share"
private var activePrimarySession: PrimarySession? = null
private lateinit var sessions: Sessions

override fun onCreate(savedInstanceState: Bundle?) {
 
super.onCreate(savedInstanceState)
  sessions
= Sessions.create(context = this)
}

suspend fun shareSession() {
 
val sessionId = sessions.createSession(ApplicationSessionTag("hello_world_share"))
  activePrimarySession
=
    sessions
.shareSession(
      sessionId
,
     
StartComponentRequest.Builder()
       
.setAction(HELLO_WORLD_SHARE_ACTION)
       
.setReason("Share reason here")
       
.build(),
      emptyList
(),
     
HelloWorldShareSessionStateCallback(),
   
)
}

private inner class HelloWorldShareSessionStateCallback : PrimarySessionStateCallback {

 
override fun onShareInitiated(sessionId: SessionId, numPotentialParticipants: Int) {
   
// Custom logic here for when n devices can potentially join.
   
// e.g. if there were 0, cancel/error if desired,
   
//      if non-0 maybe spin until numPotentialParticipants join etc.
 
}

 
override fun onParticipantJoined(sessionId: SessionId, participant: SessionParticipant) {
   
// Custom join logic here
    lifecycleScope
.launchWhenResumed {
     
// Example logic: send only to the participant who just joined.
     
val connection =
        checkNotNull
(activePrimarySession).getSecondaryRemoteConnectionForParticipant(participant)
      connection
.send("Initing hello, world.".toByteArray(UTF_8))
      connection
.registerReceiver(
       
object : SessionConnectionReceiver {
         
override fun onMessageReceived(participant: SessionParticipant, payload: ByteArray) {
           
val ok = payload.contentEquals("ok".toByteArray(UTF_8))
           
Log.d(TAG, "Session share initialized. ok=$ok")

           
// Example logic: broadcast to all participants, including the one
           
// that just joined.
            lifecycleScope
.launchWhenResumed {
              checkNotNull
(activePrimarySession)
               
.broadcastToSecondaries("hello, all.".toByteArray(UTF_8))
           
}
         
}
       
}
     
)
   
}
 
}

 
override fun onParticipantDeparted(sessionId: SessionId, participant: SessionParticipant) {
   
// Custom leave logic here.
 
}

 
override fun onPrimarySessionCleanup(sessionId: SessionId) {
   
// Custom cleanup logic here.
    activePrimarySession
= null
 
}

 
override fun onShareFailureWithParticipant(
    sessionId
: SessionId,
    exception
: SessionException,
    participant
: SessionParticipant
 
) {
   
// Handle error
 
}
}
// Originating side
private static final String HELLO_WORLD_SHARE_ACTION = "hello_world_share";
@Nullable private PrimarySession activePrimarySession = null;
private Sessions sessions;

@Override
public void onCreate(@Nullable Bundle savedInstanceState) {
 
super.onCreate(savedInstanceState);
  sessions
= Sessions.create(/* context= */ this);
}

private void shareSession() {
 
SessionId sessionId = sessions.createSession(new ApplicationSessionTag("hello_world_share"));
 
ListenableFuture<PrimarySession> shareSessionFuture =
      sessions
.shareSessionFuture(
          sessionId
,
         
new StartComponentRequest.Builder()
             
.setAction(HELLO_WORLD_SHARE_ACTION)
             
.setReason("Share reason here")
             
.build(),
         
Collections.emptyList(),
         
new HelloWorldShareSessionStateCallback());
 
Futures.addCallback(
      shareSessionFuture
,
     
new FutureCallback<PrimarySession>() {
       
@Override
       
public void onSuccess(PrimarySession primarySession) {
          activePrimarySession
= primarySession;
       
}

       
@Override
       
public void onFailure(Throwable t) {
         
Log.d(TAG, "Failed to share session", t);
       
}
     
},
      mainExecutor
);
}

private class HelloWorldShareSessionStateCallback implements PrimarySessionStateCallback {
 
@Override
 
public void onShareInitiated(SessionId sessionId, int numPotentialParticipants) {
   
// Custom logic here for when n devices can potentially join.
   
// e.g. if there were 0, cancel/error if desired,
   
//      if non-0 maybe spin until numPotentialParticipants join etc.
 
}

 
@Override
 
public void onParticipantJoined(SessionId sessionId, SessionParticipant participant) {
   
PrimarySession joinedSession = activePrimarySession;
   
if (joinedSession == null) {
     
return;
   
}
   
SessionRemoteConnection connection =
        joinedSession
.getSecondaryRemoteConnectionForParticipant(participant);
   
Futures.addCallback(
        connection
.sendFuture("Initiating hello, world.".getBytes()),
       
new FutureCallback<Void>() {
         
@Override
         
public void onSuccess(Void result) {
           
// Send successful.
         
}

         
@Override
         
public void onFailure(Throwable t) {
           
// Failed to send.
         
}
       
},
        mainExecutor
);
    connection
.registerReceiver(
       
new SessionConnectionReceiver() {
         
@Override
         
public void onMessageReceived(SessionParticipant participant, byte[] payload) {
           
boolean ok = new String(payload, UTF_8).equals("ok");
           
Log.d(TAG, "Session share initialized. ok=" + ok);

           
// Example logic: broadcast to all participants, including the one
           
// that just joined.
           
Futures.addCallback(
                joinedSession
.broadcastToSecondariesFuture("hello, all.".getBytes()),
               
new FutureCallback<Void>() {
                 
@Override
                 
public void onSuccess(Void result) {
                   
// Broadcast successful.
                 
}

                 
@Override
                 
public void onFailure(Throwable t) {
                   
// Failed to broadcast hello world.
                 
}
               
},
                mainExecutor
);
         
}
       
});
 
}

 
@Override
 
public void onParticipantDeparted(SessionId sessionId, SessionParticipant participant) {
   
// Custom leave logic here.
 
}

 
@Override
 
public void onPrimarySessionCleanup(SessionId sessionId) {
   
// Custom cleanup logic here.
    activePrimarySession
= null;
 
}

 
@Override
 
public void onShareFailureWithParticipant(
     
SessionId sessionId, SessionException exception, SessionParticipant participant) {
   
// Custom error handling logic here.
 
}
}

受信側:

KotlinJava
// Receiving side.

override fun onNewIntent(intent: Intent) {
 
super.onNewIntent(intent)
  lifecycleScope
.launchWhenResumed {
   
val secondarySession =
      sessions
.getSecondarySession(intent, HelloWorldSecondaryShareSessionStateCallback())
   
val remoteConnection = secondarySession.getDefaultRemoteConnection()

    remoteConnection
.registerReceiver(
     
object : SessionConnectionReceiver {
       
override fun onMessageReceived(participant: SessionParticipant, payload: ByteArray) {
         
Log.d(TAG, "Payload received: ${String(payload)}")
       
}
     
}
   
)
 
}
}

private inner class HelloWorldSecondaryShareSessionStateCallback : SecondarySessionStateCallback {
 
override fun onSecondarySessionCleanup(sessionId: SessionId) {
   
// Custom cleanup logic here.
 
}
}
// Receiving side.
@Override
public void onNewIntent(Intent intent) {
 
super.onNewIntent(intent);
  sessions
= Sessions.create(this);
 
ListenableFuture<SecondarySession> secondarySessionFuture =
      sessions
.getSecondarySessionFuture(
          intent
, new HelloWorldSecondaryShareSessionStateCallback());
 
Futures.addCallback(
      secondarySessionFuture
,
     
new FutureCallback<SecondarySession>() {
       
@Override
       
public void onSuccess(SecondarySession secondarySession) {
         
SessionRemoteConnection remoteConnection =
              secondarySession
.getDefaultRemoteConnection();
          remoteConnection
.registerReceiver(
             
new SessionConnectionReceiver() {
               
@Override
               
public void onMessageReceived(SessionParticipant participant, byte[] payload) {
                 
Log.d(TAG, "Payload received: " + new String(payload, UTF_8));
               
}
             
});
       
}

       
@Override
       
public void onFailure(Throwable t) {
         
// Handle error.
       
}
     
},
      mainExecutor
);
}

private static class HelloWorldSecondaryShareSessionStateCallback
   
implements SecondarySessionStateCallback {
 
@Override
 
public void onSecondarySessionCleanup(SessionId sessionId) {
   
// Custom cleanup logic here.
 
}
}