Home | History | Annotate | Download | only in media
      1 /*
      2  * Copyright 2018 The Android Open Source Project
      3  *
      4  * Licensed under the Apache License, Version 2.0 (the "License");
      5  * you may not use this file except in compliance with the License.
      6  * You may obtain a copy of the License at
      7  *
      8  *      http://www.apache.org/licenses/LICENSE-2.0
      9  *
     10  * Unless required by applicable law or agreed to in writing, software
     11  * distributed under the License is distributed on an "AS IS" BASIS,
     12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
     13  * See the License for the specific language governing permissions and
     14  * limitations under the License.
     15  */
     16 
     17 package androidx.media;
     18 
     19 import android.content.Context;
     20 import android.media.session.MediaSessionManager;
     21 import android.support.test.filters.SmallTest;
     22 import android.support.test.runner.AndroidJUnit4;
     23 
     24 import androidx.media.MediaSession2.ControllerInfo;
     25 import androidx.media.MediaSession2.SessionCallback;
     26 
     27 import org.junit.After;
     28 import org.junit.Before;
     29 import org.junit.Ignore;
     30 import org.junit.Test;
     31 import org.junit.runner.RunWith;
     32 
     33 
     34 /**
     35  * Tests {@link MediaSessionManager} with {@link MediaSession2} specific APIs.
     36  */
     37 @RunWith(AndroidJUnit4.class)
     38 @SmallTest
     39 @Ignore
     40 public class MediaSessionManager_MediaSession2Test extends MediaSession2TestBase {
     41     private static final String TAG = "MediaSessionManager_MediaSession2Test";
     42 
     43     private MediaSessionManager mManager;
     44     private MediaSession2 mSession;
     45 
     46     @Before
     47     @Override
     48     public void setUp() throws Exception {
     49         super.setUp();
     50         mManager = (MediaSessionManager) mContext.getSystemService(Context.MEDIA_SESSION_SERVICE);
     51 
     52         // Specify TAG here so {@link MediaSession2.getInstance()} doesn't complaint about
     53         // per test thread differs across the {@link MediaSession2} with the same TAG.
     54         final MockPlayer player = new MockPlayer(1);
     55         mSession = new MediaSession2.Builder(mContext)
     56                 .setPlayer(player)
     57                 .setSessionCallback(sHandlerExecutor, new SessionCallback() { })
     58                 .setId(TAG)
     59                 .build();
     60     }
     61 
     62     @After
     63     @Override
     64     public void cleanUp() throws Exception {
     65         super.cleanUp();
     66         sHandler.removeCallbacksAndMessages(null);
     67         mSession.close();
     68     }
     69 
     70     // TODO(jaewan): Make this host-side test to see per-user behavior.
     71     @Ignore
     72     @Test
     73     public void testGetMediaSession2Tokens_hasMediaController() throws InterruptedException {
     74         prepareLooper();
     75         final MockPlayer player = (MockPlayer) mSession.getPlayer();
     76         player.notifyPlaybackState(MediaPlayerInterface.PLAYER_STATE_IDLE);
     77 
     78         MediaController2 controller = null;
     79 //        List<SessionToken2> tokens = mManager.getActiveSessionTokens();
     80 //        assertNotNull(tokens);
     81 //        for (int i = 0; i < tokens.size(); i++) {
     82 //            SessionToken2 token = tokens.get(i);
     83 //            if (mContext.getPackageName().equals(token.getPackageName())
     84 //                    && TAG.equals(token.getId())) {
     85 //                assertNull(controller);
     86 //                controller = createController(token);
     87 //            }
     88 //        }
     89 //        assertNotNull(controller);
     90 //
     91 //        // Test if the found controller is correct one.
     92 //        assertEquals(MediaPlayerInterface.PLAYER_STATE_IDLE, controller.getPlayerState());
     93 //        controller.play();
     94 //
     95 //        assertTrue(player.mCountDownLatch.await(WAIT_TIME_MS, TimeUnit.MILLISECONDS));
     96 //        assertTrue(player.mPlayCalled);
     97     }
     98 
     99     /**
    100      * Test if server recognizes a session even if the session refuses the connection from server.
    101      *
    102      * @throws InterruptedException
    103      */
    104     @Test
    105     public void testGetSessionTokens_sessionRejected() throws InterruptedException {
    106         prepareLooper();
    107         mSession.close();
    108         mSession = new MediaSession2.Builder(mContext).setPlayer(new MockPlayer(0))
    109                 .setId(TAG).setSessionCallback(sHandlerExecutor, new SessionCallback() {
    110                     @Override
    111                     public SessionCommandGroup2 onConnect(
    112                             MediaSession2 session, ControllerInfo controller) {
    113                         // Reject all connection request.
    114                         return null;
    115                     }
    116                 }).build();
    117 
    118         boolean foundSession = false;
    119 //        List<SessionToken2> tokens = mManager.getActiveSessionTokens();
    120 //        assertNotNull(tokens);
    121 //        for (int i = 0; i < tokens.size(); i++) {
    122 //            SessionToken2 token = tokens.get(i);
    123 //            if (mContext.getPackageName().equals(token.getPackageName())
    124 //                    && TAG.equals(token.getId())) {
    125 //                assertFalse(foundSession);
    126 //                foundSession = true;
    127 //            }
    128 //        }
    129 //        assertTrue(foundSession);
    130     }
    131 
    132     @Test
    133     public void testGetMediaSession2Tokens_sessionClosed() throws InterruptedException {
    134         prepareLooper();
    135         mSession.close();
    136 
    137         // When a session is closed, it should lose binder connection between server immediately.
    138         // So server will forget the session.
    139 //        List<SessionToken2> tokens = mManager.getActiveSessionTokens();
    140 //        for (int i = 0; i < tokens.size(); i++) {
    141 //            SessionToken2 token = tokens.get(i);
    142 //            assertFalse(mContext.getPackageName().equals(token.getPackageName())
    143 //                    && TAG.equals(token.getId()));
    144 //        }
    145     }
    146 
    147     @Test
    148     public void testGetMediaSessionService2Token() throws InterruptedException {
    149         prepareLooper();
    150         boolean foundTestSessionService = false;
    151         boolean foundTestLibraryService = false;
    152 //        List<SessionToken2> tokens = mManager.getSessionServiceTokens();
    153 //        for (int i = 0; i < tokens.size(); i++) {
    154 //            SessionToken2 token = tokens.get(i);
    155 //            if (mContext.getPackageName().equals(token.getPackageName())
    156 //                    && MockMediaSessionService2.ID.equals(token.getId())) {
    157 //                assertFalse(foundTestSessionService);
    158 //                assertEquals(SessionToken2.TYPE_SESSION_SERVICE, token.getType());
    159 //                foundTestSessionService = true;
    160 //            } else if (mContext.getPackageName().equals(token.getPackageName())
    161 //                    && MockMediaLibraryService2.ID.equals(token.getId())) {
    162 //                assertFalse(foundTestLibraryService);
    163 //                assertEquals(SessionToken2.TYPE_LIBRARY_SERVICE, token.getType());
    164 //                foundTestLibraryService = true;
    165 //            }
    166 //        }
    167 //        assertTrue(foundTestSessionService);
    168 //        assertTrue(foundTestLibraryService);
    169     }
    170 
    171     @Test
    172     public void testGetAllSessionTokens() throws InterruptedException {
    173         prepareLooper();
    174         boolean foundTestSession = false;
    175         boolean foundTestSessionService = false;
    176         boolean foundTestLibraryService = false;
    177 //        List<SessionToken2> tokens = mManager.getAllSessionTokens();
    178 //        for (int i = 0; i < tokens.size(); i++) {
    179 //            SessionToken2 token = tokens.get(i);
    180 //            if (!mContext.getPackageName().equals(token.getPackageName())) {
    181 //                continue;
    182 //            }
    183 //            switch (token.getId()) {
    184 //                case TAG:
    185 //                    assertFalse(foundTestSession);
    186 //                    foundTestSession = true;
    187 //                    break;
    188 //                case MockMediaSessionService2.ID:
    189 //                    assertFalse(foundTestSessionService);
    190 //                    foundTestSessionService = true;
    191 //                    assertEquals(SessionToken2.TYPE_SESSION_SERVICE, token.getType());
    192 //                    break;
    193 //                case MockMediaLibraryService2.ID:
    194 //                    assertFalse(foundTestLibraryService);
    195 //                    assertEquals(SessionToken2.TYPE_LIBRARY_SERVICE, token.getType());
    196 //                    foundTestLibraryService = true;
    197 //                    break;
    198 //                default:
    199 //                    fail("Unexpected session " + token + " exists in the package");
    200 //            }
    201 //        }
    202 //        assertTrue(foundTestSession);
    203 //        assertTrue(foundTestSessionService);
    204 //        assertTrue(foundTestLibraryService);
    205     }
    206 
    207     @Test
    208     public void testAddOnSessionTokensChangedListener() throws InterruptedException {
    209 //        prepareLooper();
    210 //        TokensChangedListener listener = new TokensChangedListener();
    211 //        mManager.addOnSessionTokensChangedListener(sHandlerExecutor, listener);
    212 //
    213 //        listener.reset();
    214 //        MediaSession2 session1 = new MediaSession2.Builder(mContext)
    215 //                .setPlayer(new MockPlayer(0))
    216 //                .setId(UUID.randomUUID().toString())
    217 //                .build();
    218 //        assertTrue(listener.await());
    219 //        assertTrue(listener.findToken(session1.getToken()));
    220 //
    221 //        listener.reset();
    222 //        session1.close();
    223 //        assertTrue(listener.await());
    224 //        assertFalse(listener.findToken(session1.getToken()));
    225 //
    226 //        listener.reset();
    227 //        MediaSession2 session2 = new MediaSession2.Builder(mContext)
    228 //                .setPlayer(new MockPlayer(0))
    229 //                .setId(UUID.randomUUID().toString())
    230 //                .build();
    231 //        assertTrue(listener.await());
    232 //        assertFalse(listener.findToken(session1.getToken()));
    233 //        assertTrue(listener.findToken(session2.getToken()));
    234 //
    235 //        listener.reset();
    236 //        MediaSession2 session3 = new MediaSession2.Builder(mContext)
    237 //                .setPlayer(new MockPlayer(0))
    238 //                .setId(UUID.randomUUID().toString())
    239 //                .build();
    240 //        assertTrue(listener.await());
    241 //        assertFalse(listener.findToken(session1.getToken()));
    242 //        assertTrue(listener.findToken(session2.getToken()));
    243 //        assertTrue(listener.findToken(session3.getToken()));
    244 //
    245 //        listener.reset();
    246 //        session2.close();
    247 //        assertTrue(listener.await());
    248 //        assertFalse(listener.findToken(session1.getToken()));
    249 //        assertFalse(listener.findToken(session2.getToken()));
    250 //        assertTrue(listener.findToken(session3.getToken()));
    251 //
    252 //        listener.reset();
    253 //        session3.close();
    254 //        assertTrue(listener.await());
    255 //        assertFalse(listener.findToken(session1.getToken()));
    256 //        assertFalse(listener.findToken(session2.getToken()));
    257 //        assertFalse(listener.findToken(session3.getToken()));
    258 //
    259 //        mManager.removeOnSessionTokensChangedListener(listener);
    260     }
    261 
    262     @Test
    263     public void testRemoveOnSessionTokensChangedListener() throws InterruptedException {
    264 //        prepareLooper();
    265 //        TokensChangedListener listener = new TokensChangedListener();
    266 //        mManager.addOnSessionTokensChangedListener(sHandlerExecutor, listener);
    267 //
    268 //        listener.reset();
    269 //        MediaSession2 session1 = new MediaSession2.Builder(mContext)
    270 //                .setPlayer(new MockPlayer(0))
    271 //                .setId(UUID.randomUUID().toString())
    272 //                .build();
    273 //        assertTrue(listener.await());
    274 //
    275 //        mManager.removeOnSessionTokensChangedListener(listener);
    276 //
    277 //        listener.reset();
    278 //        session1.close();
    279 //        assertFalse(listener.await());
    280 //
    281 //        listener.reset();
    282 //        MediaSession2 session2 = new MediaSession2.Builder(mContext)
    283 //                .setPlayer(new MockPlayer(0))
    284 //                .setId(UUID.randomUUID().toString())
    285 //                .build();
    286 //        assertFalse(listener.await());
    287 //
    288 //        listener.reset();
    289 //        MediaSession2 session3 = new MediaSession2.Builder(mContext)
    290 //                .setPlayer(new MockPlayer(0))
    291 //                .setId(UUID.randomUUID().toString())
    292 //                .build();
    293 //        assertFalse(listener.await());
    294 //
    295 //        listener.reset();
    296 //        session2.close();
    297 //        assertFalse(listener.await());
    298 //
    299 //        listener.reset();
    300 //        session3.close();
    301 //        assertFalse(listener.await());
    302     }
    303 
    304 //    private class TokensChangedListener implements OnSessionTokensChangedListener {
    305 //        private CountDownLatch mLatch;
    306 //        private List<SessionToken2> mTokens;
    307 //
    308 //        private void reset() {
    309 //            mLatch = new CountDownLatch(1);
    310 //            mTokens = null;
    311 //        }
    312 //
    313 //        private boolean await() throws InterruptedException {
    314 //            return mLatch.await(WAIT_TIME_MS, TimeUnit.MILLISECONDS);
    315 //        }
    316 //
    317 //        private boolean findToken(SessionToken2 token) {
    318 //            return mTokens.contains(token);
    319 //        }
    320 //
    321 //        @Override
    322 //        public void onSessionTokensChanged(List<SessionToken2> tokens) {
    323 //            mTokens = tokens;
    324 //            mLatch.countDown();
    325 //        }
    326 //    }
    327 }
    328