Add AnimatedVectorDrawable support for VideoPreference

- We are planning to use animation vector drawable to replace mp4
file to reduce apk size
- Add vectorAnimation attr in VideoPreference
- Delegate VideoPreference media control to AnimationController

Bug: 143270527
Test: manual, robolectric
Change-Id: Ia5859f928a9082085cdf715c762f964e1c99e003

tests/robotests/src/com/android/settings/testutils/shadow/ShadowSettingsMediaPlayer.java

@@ -0,0 +1,51 @@
+/*
+ * Copyright (C) 2019 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.android.settings.testutils.shadow;
+
+import static org.robolectric.shadows.ShadowMediaPlayer.State.INITIALIZED;
+
+import android.content.Context;
+import android.media.MediaPlayer;
+import android.net.Uri;
+
+import org.robolectric.annotation.Implementation;
+import org.robolectric.annotation.Implements;
+import org.robolectric.shadow.api.Shadow;
+import org.robolectric.shadows.ShadowMediaPlayer;
+import org.robolectric.shadows.util.DataSource;
+
+@Implements(MediaPlayer.class)
+public class ShadowSettingsMediaPlayer extends ShadowMediaPlayer {
+
+    @Implementation
+    public static MediaPlayer create(Context context, Uri uri) {
+        final DataSource ds = DataSource.toDataSource(context, uri);
+        addMediaInfo(ds, new ShadowMediaPlayer.MediaInfo());
+
+        final MediaPlayer mp = new MediaPlayer();
+        final ShadowMediaPlayer shadow = Shadow.extract(mp);
+        try {
+            shadow.setDataSource(ds);
+            shadow.setState(INITIALIZED);
+            mp.prepare();
+        } catch (Exception e) {
+            return null;
+        }
+
+        return mp;
+    }
+}

tests/robotests/src/com/android/settings/widget/VideoPreferenceTest.java

@@ -18,26 +18,24 @@ package com.android.settings.widget;
 
 import static com.google.common.truth.Truth.assertThat;
 
-import static org.mockito.ArgumentMatchers.any;
-import static org.mockito.ArgumentMatchers.anyInt;
 import static org.mockito.ArgumentMatchers.eq;
-import static org.mockito.Mockito.doReturn;
 import static org.mockito.Mockito.mock;
 import static org.mockito.Mockito.never;
+import static org.mockito.Mockito.spy;
 import static org.mockito.Mockito.verify;
 import static org.mockito.Mockito.when;
 
 import android.content.Context;
 import android.graphics.SurfaceTexture;
-import android.media.MediaPlayer;
 import android.view.LayoutInflater;
 import android.view.TextureView;
-
 import android.view.View;
 import android.widget.ImageView;
+
 import androidx.preference.PreferenceViewHolder;
 
 import com.android.settings.R;
+import com.android.settings.testutils.shadow.ShadowSettingsMediaPlayer;
 
 import org.junit.Before;
 import org.junit.Test;
@@ -46,14 +44,15 @@ import org.mockito.Mock;
 import org.mockito.MockitoAnnotations;
 import org.robolectric.RobolectricTestRunner;
 import org.robolectric.RuntimeEnvironment;
+import org.robolectric.annotation.Config;
 
 @RunWith(RobolectricTestRunner.class)
+@Config(shadows = ShadowSettingsMediaPlayer.class)
 public class VideoPreferenceTest {
     private static final int VIDEO_WIDTH = 100;
     private static final int VIDEO_HEIGHT = 150;
 
-    @Mock
-    private MediaPlayer mMediaPlayer;
+    private VideoPreference.AnimationController mAnimationController;
     @Mock
     private ImageView fakePreview;
     @Mock
@@ -67,10 +66,12 @@ public class VideoPreferenceTest {
         MockitoAnnotations.initMocks(this);
 
         mContext = RuntimeEnvironment.application;
+        mAnimationController = spy(
+                new MediaAnimationController(mContext, R.raw.accessibility_screen_magnification));
         mVideoPreference = new VideoPreference(mContext, null /* attrs */);
-        mVideoPreference.mMediaPlayer = mMediaPlayer;
-        when(mMediaPlayer.getVideoWidth()).thenReturn(VIDEO_WIDTH);
-        when(mMediaPlayer.getVideoHeight()).thenReturn(VIDEO_HEIGHT);
+        mVideoPreference.mAnimationController = mAnimationController;
+        when(mAnimationController.getVideoWidth()).thenReturn(VIDEO_WIDTH);
+        when(mAnimationController.getVideoHeight()).thenReturn(VIDEO_HEIGHT);
 
         mPreferenceViewHolder = PreferenceViewHolder.createInstanceForTests(
                 LayoutInflater.from(mContext).inflate(R.layout.video_preference, null));
@@ -91,17 +92,17 @@ public class VideoPreferenceTest {
     @Test
     public void onSurfaceTextureUpdated_viewInvisible_shouldNotStartPlayingVideo() {
         final TextureView video =
-            (TextureView) mPreferenceViewHolder.findViewById(R.id.video_texture_view);
+                (TextureView) mPreferenceViewHolder.findViewById(R.id.video_texture_view);
         mVideoPreference.mAnimationAvailable = true;
-        mVideoPreference.mVideoReady = true;
-        mVideoPreference.onViewInvisible();
         mVideoPreference.onBindViewHolder(mPreferenceViewHolder);
-        when(mMediaPlayer.isPlaying()).thenReturn(false);
+        mAnimationController.attachView(video, fakePreview, fakePlayButton);
+        when(mAnimationController.isPlaying()).thenReturn(false);
         final TextureView.SurfaceTextureListener listener = video.getSurfaceTextureListener();
 
+        mVideoPreference.onViewInvisible();
         listener.onSurfaceTextureUpdated(mock(SurfaceTexture.class));
 
-        verify(mMediaPlayer, never()).start();
+        verify(mAnimationController, never()).start();
     }
 
     @Test
@@ -110,32 +111,30 @@ public class VideoPreferenceTest {
 
         mVideoPreference.onViewInvisible();
 
-        verify(mMediaPlayer).release();
+        verify(mAnimationController).release();
     }
 
     @Test
     public void updateViewStates_paused_updatesViews() {
-        when(mMediaPlayer.isPlaying()).thenReturn(true);
-        mVideoPreference.updateViewStates(fakePreview, fakePlayButton);
+        mAnimationController.start();
+
+        mVideoPreference.mAnimationController.attachView(new TextureView(mContext), fakePreview,
+                fakePlayButton);
+
         verify(fakePlayButton).setVisibility(eq(View.VISIBLE));
         verify(fakePreview).setVisibility(eq(View.VISIBLE));
-        verify(mMediaPlayer).pause();
+        assertThat(mAnimationController.isPlaying()).isFalse();
     }
 
     @Test
     public void updateViewStates_playing_updatesViews() {
-        when(mMediaPlayer.isPlaying()).thenReturn(false);
-        mVideoPreference.updateViewStates(fakePreview, fakePlayButton);
+        mAnimationController.pause();
+
+        mVideoPreference.mAnimationController.attachView(new TextureView(mContext), fakePreview,
+                fakePlayButton);
+
         verify(fakePlayButton).setVisibility(eq(View.GONE));
         verify(fakePreview).setVisibility(eq(View.GONE));
-        verify(mMediaPlayer).start();
-    }
-
-    @Test
-    public void updateViewStates_noMediaPlayer_skips() {
-        mVideoPreference.mMediaPlayer = null;
-        mVideoPreference.updateViewStates(fakePreview, fakePlayButton);
-        verify(fakePlayButton, never()).setVisibility(anyInt());
-        verify(fakePreview, never()).setVisibility(anyInt());
+        assertThat(mAnimationController.isPlaying()).isTrue();
     }
 }