| /* |
| * Copyright (C) 2021 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.providers.media.photopicker; |
| |
| import static android.provider.CloudMediaProviderContract.AlbumColumns; |
| import static android.provider.CloudMediaProviderContract.AlbumColumns.ALBUM_ID_CAMERA; |
| import static android.provider.CloudMediaProviderContract.AlbumColumns.ALBUM_ID_DOWNLOADS; |
| import static android.provider.CloudMediaProviderContract.AlbumColumns.ALBUM_ID_FAVORITES; |
| import static android.provider.CloudMediaProviderContract.AlbumColumns.ALBUM_ID_SCREENSHOTS; |
| import static android.provider.CloudMediaProviderContract.AlbumColumns.ALBUM_ID_VIDEOS; |
| import static android.provider.CloudMediaProviderContract.MediaColumns; |
| import static android.provider.MediaStore.VOLUME_EXTERNAL; |
| |
| import static com.android.providers.media.photopicker.PickerSyncController.LOCAL_PICKER_PROVIDER_AUTHORITY; |
| import static com.android.providers.media.util.MimeUtils.isImageMimeType; |
| import static com.android.providers.media.util.MimeUtils.isVideoMimeType; |
| |
| import static com.google.common.truth.Truth.assertThat; |
| import static com.google.common.truth.Truth.assertWithMessage; |
| |
| import android.Manifest; |
| import android.app.Instrumentation; |
| import android.app.UiAutomation; |
| import android.content.ContentResolver; |
| import android.content.ContentValues; |
| import android.content.Context; |
| import android.content.res.AssetFileDescriptor; |
| import android.database.Cursor; |
| import android.net.Uri; |
| import android.os.Bundle; |
| import android.os.Environment; |
| import android.os.ParcelFileDescriptor; |
| import android.provider.CloudMediaProviderContract; |
| import android.provider.MediaStore; |
| import android.util.Log; |
| import android.util.Pair; |
| |
| import androidx.test.InstrumentationRegistry; |
| |
| import com.android.providers.media.IsolatedContext; |
| import com.android.providers.media.PickerProviderMediaGenerator; |
| import com.android.providers.media.PickerProviderMediaGenerator.MediaGenerator; |
| import com.android.providers.media.TestConfigStore; |
| import com.android.providers.media.cloudproviders.CloudProviderPrimary; |
| import com.android.providers.media.photopicker.data.ItemsProvider; |
| import com.android.providers.media.photopicker.data.model.Category; |
| import com.android.providers.media.photopicker.data.model.UserId; |
| |
| import com.google.common.io.ByteStreams; |
| |
| import org.junit.After; |
| import org.junit.Before; |
| import org.junit.Test; |
| |
| import java.io.File; |
| import java.io.FileInputStream; |
| import java.io.FileOutputStream; |
| import java.io.IOException; |
| import java.io.InterruptedIOException; |
| import java.util.ArrayList; |
| import java.util.Arrays; |
| import java.util.List; |
| import java.util.function.Consumer; |
| |
| public class ItemsProviderTest { |
| /** |
| * To help avoid flaky tests, give ourselves a unique nonce to be used for |
| * all filesystem paths, so that we don't risk conflicting with previous |
| * test runs. |
| */ |
| private static final String NONCE = String.valueOf(System.nanoTime()); |
| private static final String TAG = "ItemsProviderTest"; |
| private static final String VIDEO_FILE_NAME = TAG + "_file_" + NONCE + ".mp4"; |
| private static final String IMAGE_FILE_NAME = TAG + "_file_" + NONCE + ".jpg"; |
| private static final String HIDDEN_DIR_NAME = TAG + "_hidden_dir_" + NONCE; |
| |
| private static final Instrumentation sInstrumentation = |
| InstrumentationRegistry.getInstrumentation(); |
| private static final Context sTargetContext = sInstrumentation.getTargetContext(); |
| // We are in a self-instrumentation test - MediaProviderTests - so "target" package name and |
| // "own" package are the same: com.android.providers.media.tests. |
| private static final String sTargetPackageName = sTargetContext.getPackageName(); |
| private ContentResolver mIsolatedResolver; |
| private ItemsProvider mItemsProvider; |
| private TestConfigStore mConfigStore; |
| |
| @Before |
| public void setUp() throws Exception { |
| final UiAutomation uiAutomation = sInstrumentation.getUiAutomation(); |
| uiAutomation.adoptShellPermissionIdentity(Manifest.permission.LOG_COMPAT_CHANGE, |
| Manifest.permission.READ_COMPAT_CHANGE_CONFIG, |
| Manifest.permission.READ_DEVICE_CONFIG, |
| Manifest.permission.INTERACT_ACROSS_USERS); |
| |
| mConfigStore = new TestConfigStore(); |
| // Remove sync delay to avoid flaky tests |
| mConfigStore.setPickerSyncDelayMs(0); |
| |
| final Context isolatedContext = new IsolatedContext(sTargetContext, /* tag */ "databases", |
| /* asFuseThread */ false, sTargetContext.getUser(), mConfigStore); |
| mIsolatedResolver = isolatedContext.getContentResolver(); |
| mItemsProvider = new ItemsProvider(isolatedContext); |
| |
| // Wait for MediaStore to be Idle to reduce flakes caused by database updates |
| MediaStore.waitForIdle(mIsolatedResolver); |
| } |
| |
| @After |
| public void tearDown() throws Exception { |
| setCloudProvider(null); |
| } |
| |
| /** |
| * Tests {@link ItemsProvider#getAllCategories(String[], UserId)} to return correct info |
| * about {@link #ALBUM_ID_CAMERA}. |
| */ |
| @Test |
| public void testGetCategories_camera() throws Exception { |
| Cursor c = mItemsProvider.getAllCategories(/* mimeType */ null, /* userId */ null); |
| assertThat(c.getCount()).isEqualTo(0); |
| |
| // Create 1 image file in Camera dir to test |
| final File cameraDir = getCameraDir(); |
| File imageFile = assertCreateNewImage(cameraDir); |
| try { |
| assertGetCategoriesMatchSingle(ALBUM_ID_CAMERA, /* numberOfItems */ 1); |
| } finally { |
| imageFile.delete(); |
| } |
| } |
| |
| /** |
| * Tests {@link ItemsProvider#getAllCategories(String[], UserId)} to return correct info |
| * about {@link #ALBUM_ID_CAMERA}. |
| */ |
| @Test |
| public void testGetCategories_not_camera() throws Exception { |
| Cursor c = mItemsProvider.getAllCategories(/* mimeType */ null, /* userId */ null); |
| assertThat(c.getCount()).isEqualTo(0); |
| |
| // negative test case: image file which should not be returned in Camera category |
| final File picturesDir = getPicturesDir(); |
| File nonCameraImageFile = assertCreateNewImage(picturesDir); |
| try { |
| assertGetCategoriesMatchSingle(ALBUM_ID_CAMERA, /* numberOfItems */ 0); |
| } finally { |
| nonCameraImageFile.delete(); |
| } |
| } |
| |
| /** |
| * Tests {@link ItemsProvider#getAllCategories(String[], UserId)} to return correct info |
| * about {@link #ALBUM_ID_VIDEOS}. |
| */ |
| @Test |
| public void testGetCategories_videos() throws Exception { |
| Cursor c = mItemsProvider.getAllCategories(/* mimeType */ null, /* userId */ null); |
| assertThat(c.getCount()).isEqualTo(0); |
| |
| // Create 1 video file in Movies dir to test |
| final File moviesDir = getMoviesDir(); |
| File videoFile = assertCreateNewVideo(moviesDir); |
| try { |
| assertGetCategoriesMatchSingle(ALBUM_ID_VIDEOS, /* numberOfItems */ 1); |
| } finally { |
| videoFile.delete(); |
| } |
| } |
| |
| /** |
| * Tests {@link ItemsProvider#getAllCategories(String[], UserId)} to return correct info |
| * about {@link #ALBUM_ID_VIDEOS}. |
| */ |
| @Test |
| public void testGetCategories_not_videos() throws Exception { |
| Cursor c = mItemsProvider.getAllCategories(/* mimeType */ null, /* userId */ null); |
| assertThat(c.getCount()).isEqualTo(0); |
| |
| // negative test case: image file which should not be returned in Videos category |
| final File picturesDir = getPicturesDir(); |
| File imageFile = assertCreateNewImage(picturesDir); |
| try { |
| assertGetCategoriesMatchSingle(ALBUM_ID_VIDEOS, /* numberOfItems */ 0); |
| } finally { |
| imageFile.delete(); |
| } |
| } |
| |
| /** |
| * Tests {@link ItemsProvider#getAllCategories(String[], UserId)} to return correct info |
| * about {@link #ALBUM_ID_SCREENSHOTS}. |
| */ |
| @Test |
| public void testGetCategories_screenshots() throws Exception { |
| Cursor c = mItemsProvider.getAllCategories(/* mimeType */ null, /* userId */ null); |
| assertThat(c.getCount()).isEqualTo(0); |
| |
| // Create 1 image file in Screenshots dir to test |
| final File screenshotsDir = getScreenshotsDir(); |
| File imageFile = assertCreateNewImage(screenshotsDir); |
| // Create 1 image file in Screenshots dir of Downloads dir |
| final File screenshotsDirInDownloadsDir = getScreenshotsDirFromDownloadsDir(); |
| File imageFileInScreenshotDirInDownloads = |
| assertCreateNewImage(screenshotsDirInDownloadsDir); |
| |
| // Add a top level /Screenshots directory and add a test image inside of it. |
| createTestScreenshotImages(); |
| |
| // This file should not be included since it's not a valid screenshot directory, even though |
| // it looks like one. |
| final File myAlbumScreenshotsDir = |
| new File(getPicturesDir(), "MyAlbum" + Environment.DIRECTORY_SCREENSHOTS); |
| final File myAlbumScreenshotsImg = assertCreateNewImage(myAlbumScreenshotsDir); |
| |
| try { |
| assertGetCategoriesMatchMultiple(Arrays.asList( |
| Pair.create(ALBUM_ID_SCREENSHOTS, 3), |
| Pair.create(ALBUM_ID_DOWNLOADS, 1) |
| )); |
| } finally { |
| imageFile.delete(); |
| imageFileInScreenshotDirInDownloads.delete(); |
| myAlbumScreenshotsImg.delete(); |
| myAlbumScreenshotsDir.delete(); |
| deleteTopLevelScreenshotDir(); |
| } |
| } |
| |
| /** |
| * Tests {@link ItemsProvider#getAllCategories(String[], UserId)} to return correct info |
| * about {@link #ALBUM_ID_SCREENSHOTS}. |
| */ |
| @Test |
| public void testGetCategories_not_screenshots() throws Exception { |
| Cursor c = mItemsProvider.getAllCategories(/* mimeType */ null, /* userId */ null); |
| assertThat(c.getCount()).isEqualTo(0); |
| |
| // negative test case: image file which should not be returned in Screenshots category |
| final File cameraDir = getCameraDir(); |
| File imageFile = assertCreateNewImage(cameraDir); |
| try { |
| assertGetCategoriesMatchSingle(ALBUM_ID_SCREENSHOTS, /* numberOfItems */ 0); |
| } finally { |
| imageFile.delete(); |
| } |
| } |
| |
| /** |
| * Tests {@link ItemsProvider#getAllCategories(String[], UserId)} to return correct info |
| * about {@link AlbumColumns#ALBUM_ID_FAVORITES}. |
| */ |
| @Test |
| public void testGetCategories_favorites() throws Exception { |
| Cursor c = mItemsProvider.getAllCategories(/* mimeType */ null, /* userId */ null); |
| assertThat(c.getCount()).isEqualTo(0); |
| |
| // positive test case: image file which should be returned in favorites category |
| final File picturesDir = getPicturesDir(); |
| final File imageFile = assertCreateNewImage(picturesDir); |
| setIsFavorite(imageFile); |
| try { |
| assertGetCategoriesMatchSingle(ALBUM_ID_FAVORITES, /* numberOfItems */1); |
| } finally { |
| imageFile.delete(); |
| } |
| } |
| |
| /** |
| * Tests {@link ItemsProvider#getAllCategories(String[], UserId)} to return correct info |
| * about {@link AlbumColumns#ALBUM_ID_FAVORITES}. |
| */ |
| @Test |
| public void testGetCategories_not_favorites() throws Exception { |
| Cursor c = mItemsProvider.getAllCategories(/* mimeType */ null, /* userId */ null); |
| assertThat(c.getCount()).isEqualTo(0); |
| |
| // negative test case: image file which should not be returned in favorites category |
| final File picturesDir = getPicturesDir(); |
| final File nonFavImageFile = assertCreateNewImage(picturesDir); |
| try { |
| assertGetCategoriesMatchSingle(ALBUM_ID_FAVORITES, /* numberOfItems */ 0); |
| } finally { |
| nonFavImageFile.delete(); |
| } |
| } |
| |
| /** |
| * Tests {@link ItemsProvider#getAllCategories(String[], UserId)} to return correct info |
| * about {@link #ALBUM_ID_DOWNLOADS}. |
| */ |
| @Test |
| public void testGetCategories_downloads() throws Exception { |
| Cursor c = mItemsProvider.getAllCategories(/* mimeType */ null, /* userId */ null); |
| assertThat(c.getCount()).isEqualTo(0); |
| |
| // Create 1 image file in Downloads dir to test |
| final File downloadsDir = getDownloadsDir(); |
| final File imageFile = assertCreateNewImage(downloadsDir); |
| try { |
| assertGetCategoriesMatchSingle(ALBUM_ID_DOWNLOADS, /* numberOfItems */ 1); |
| } finally { |
| imageFile.delete(); |
| } |
| } |
| |
| /** |
| * Tests {@link ItemsProvider#getAllCategories(String[], UserId)} to return correct info |
| * about {@link #ALBUM_ID_DOWNLOADS}. |
| */ |
| @Test |
| public void testGetCategories_not_downloads() throws Exception { |
| Cursor c = mItemsProvider.getAllCategories(/* mimeType */ null, /* userId */ null); |
| assertThat(c.getCount()).isEqualTo(0); |
| |
| // negative test case: image file which should not be returned in Downloads category |
| final File picturesDir = getPicturesDir(); |
| final File nonDownloadsImageFile = assertCreateNewImage(picturesDir); |
| try { |
| assertGetCategoriesMatchSingle(ALBUM_ID_DOWNLOADS, /* numberOfItems */ 0); |
| } finally { |
| nonDownloadsImageFile.delete(); |
| } |
| } |
| |
| /** |
| * Tests {@link ItemsProvider#getAllCategories(String[], UserId)} to return correct info |
| * about {@link #ALBUM_ID_VIDEOS}. |
| */ |
| @Test |
| public void testGetCategories_camera_and_videos() throws Exception { |
| Cursor c = mItemsProvider.getAllCategories(/* mimeType */ null, /* userId */ null); |
| assertThat(c.getCount()).isEqualTo(0); |
| |
| // Create 1 video file in Camera dir to test |
| final File cameraDir = getCameraDir(); |
| File videoFile = assertCreateNewVideo(cameraDir); |
| try { |
| assertGetCategoriesMatchMultiple(Arrays.asList( |
| Pair.create(ALBUM_ID_VIDEOS, 1), |
| Pair.create(ALBUM_ID_CAMERA, 1) |
| )); |
| } finally { |
| videoFile.delete(); |
| } |
| } |
| |
| /** |
| * Tests {@link ItemsProvider#getAllCategories(String[], UserId)} to return correct info |
| * about {@link AlbumColumns#ALBUM_ID_FAVORITES}. |
| */ |
| @Test |
| public void testGetCategories_screenshots_and_favorites() throws Exception { |
| Cursor c = mItemsProvider.getAllCategories(/* mimeType */ null, /* userId */ null); |
| assertThat(c.getCount()).isEqualTo(0); |
| |
| // Create 1 image file in Screenshots dir to test |
| final File screenshotsDir = getScreenshotsDir(); |
| File imageFile = assertCreateNewImage(screenshotsDir); |
| setIsFavorite(imageFile); |
| try { |
| assertGetCategoriesMatchMultiple(Arrays.asList( |
| Pair.create(ALBUM_ID_FAVORITES, 1), |
| Pair.create(ALBUM_ID_SCREENSHOTS, 1) |
| )); |
| } finally { |
| imageFile.delete(); |
| } |
| } |
| |
| /** |
| * Tests {@link ItemsProvider#getAllCategories(String[], UserId)} to return correct info |
| * about {@link AlbumColumns#ALBUM_ID_DOWNLOADS} and {@link AlbumColumns#ALBUM_ID_FAVORITES}. |
| */ |
| @Test |
| public void testGetCategories_downloads_and_favorites() throws Exception { |
| Cursor c = mItemsProvider.getAllCategories(/* mimeType */ null, /* userId */ null); |
| assertThat(c.getCount()).isEqualTo(0); |
| |
| // Create 1 image file in Screenshots dir to test |
| final File downloadsDir = getDownloadsDir(); |
| File imageFile = assertCreateNewImage(downloadsDir); |
| setIsFavorite(imageFile); |
| try { |
| assertGetCategoriesMatchMultiple(Arrays.asList( |
| Pair.create(ALBUM_ID_FAVORITES, 1), |
| Pair.create(ALBUM_ID_DOWNLOADS, 1) |
| )); |
| } finally { |
| imageFile.delete(); |
| } |
| } |
| |
| /** |
| * Tests {@link ItemsProvider#getAllItems(Category, int, String[], UserId)} to return all |
| * images and videos. |
| */ |
| @Test |
| public void testGetItems() throws Exception { |
| // Create 1 image and 1 video file to test |
| // Both files should be returned. |
| File imageFile = assertCreateNewImage(); |
| File videoFile = assertCreateNewVideo(); |
| try { |
| final Cursor res = mItemsProvider.getAllItems(Category.DEFAULT, /* limit */ -1, |
| /* mimeType */ null, /* userId */ null); |
| assertThat(res).isNotNull(); |
| assertThat(res.getCount()).isEqualTo(2); |
| |
| assertThatOnlyImagesVideos(res); |
| // Reset the cursor back. Cursor#moveToPosition(-1) will reset the position to -1, |
| // but since there is no such valid cursor position, it returns false. |
| assertThat(res.moveToPosition(-1)).isFalse(); |
| assertThatAllImagesVideos(res.getCount()); |
| } finally { |
| imageFile.delete(); |
| videoFile.delete(); |
| } |
| } |
| |
| @Test |
| public void testGetItems_sortOrder() throws Exception { |
| try { |
| final long timeNow = System.nanoTime() / 1000; |
| final Uri imageFileDateNowPlus1Uri = prepareFileAndGetUri( |
| new File(getDownloadsDir(), "latest_" + IMAGE_FILE_NAME), timeNow + 1000); |
| final Uri imageFileDateNowUri |
| = prepareFileAndGetUri(new File(getDcimDir(), IMAGE_FILE_NAME), timeNow); |
| final Uri videoFileDateNowUri |
| = prepareFileAndGetUri(new File(getCameraDir(), VIDEO_FILE_NAME), timeNow); |
| |
| // This is the list of uris based on the expected sort order of items returned by |
| // ItemsProvider#getAllItems |
| List<Uri> uris = new ArrayList<>(); |
| // This is the latest image file |
| uris.add(imageFileDateNowPlus1Uri); |
| // Video file was scanned after image file, hence has higher _id than image file |
| uris.add(videoFileDateNowUri); |
| uris.add(imageFileDateNowUri); |
| |
| try (Cursor cursor = mItemsProvider.getAllItems(Category.DEFAULT, /* limit */ -1, |
| /* mimeType */ null, /* userId */ null)) { |
| assertThat(cursor).isNotNull(); |
| |
| final int expectedCount = uris.size(); |
| assertThat(cursor.getCount()).isEqualTo(expectedCount); |
| |
| int rowNum = 0; |
| assertThat(cursor.moveToFirst()).isTrue(); |
| final int idColumnIndex = cursor.getColumnIndexOrThrow(MediaColumns.ID); |
| while (rowNum < expectedCount) { |
| assertWithMessage("id at row:" + rowNum + " is expected to be" |
| + " same as id in " + uris.get(rowNum)) |
| .that(String.valueOf(cursor.getLong(idColumnIndex))) |
| .isEqualTo(uris.get(rowNum).getLastPathSegment()); |
| cursor.moveToNext(); |
| rowNum++; |
| } |
| } |
| } finally { |
| deleteAllFilesNoThrow(); |
| } |
| } |
| |
| /** |
| * Tests {@link {@link ItemsProvider#getAllItems(Category, int, String[], UserId)}} does not |
| * return hidden images/videos. |
| */ |
| @Test |
| public void testGetItems_nonMedia() throws Exception { |
| // Create 1 image and 1 video file in a hidden dir to test |
| // Both should not be returned. |
| File hiddenDir = createHiddenDir(); |
| File imageFileHidden = assertCreateNewImage(hiddenDir); |
| File videoFileHidden = assertCreateNewVideo(hiddenDir); |
| try { |
| final Cursor res = mItemsProvider.getAllItems(Category.DEFAULT, /* limit */ -1, |
| /* mimeType */ null, /* userId */ null); |
| assertThat(res).isNotNull(); |
| assertThat(res.getCount()).isEqualTo(0); |
| } finally { |
| imageFileHidden.delete(); |
| videoFileHidden.delete(); |
| hiddenDir.delete(); |
| } |
| } |
| |
| /** |
| * Tests {@link ItemsProvider#getAllItems(Category, int, String[], UserId)} to return all |
| * images and videos based on the mimeType. Image mimeType should only return images. |
| */ |
| @Test |
| public void testGetItemsImages() throws Exception { |
| // Create 1 image and 1 video file to test |
| // Only 1 should be returned. |
| File imageFile = assertCreateNewImage(); |
| File videoFile = assertCreateNewVideo(); |
| try { |
| final Cursor res = mItemsProvider.getAllItems(Category.DEFAULT, /* limit */ -1, |
| /* mimeType */ new String[]{ "image/*"}, /* userId */ null); |
| assertThat(res).isNotNull(); |
| assertThat(res.getCount()).isEqualTo(1); |
| |
| assertThatOnlyImages(res); |
| assertThatAllImages(res.getCount()); |
| } finally { |
| imageFile.delete(); |
| videoFile.delete(); |
| } |
| } |
| |
| /** |
| * Tests {@link ItemsProvider#getAllItems(Category, int, String[], UserId)} to return all |
| * images and videos based on the mimeType. Image mimeType should only return images. |
| */ |
| @Test |
| public void testGetItemsImages_png() throws Exception { |
| // Create a jpg file image. Tests negative use case, this should not be returned below. |
| File imageFile = assertCreateNewImage(); |
| try { |
| final Cursor res = mItemsProvider.getAllItems(Category.DEFAULT, /* limit */ -1, |
| /* mimeType */ new String[]{"image/png"}, /* userId */ null); |
| assertThat(res).isNotNull(); |
| assertThat(res.getCount()).isEqualTo(0); |
| } finally { |
| imageFile.delete(); |
| } |
| } |
| |
| /** |
| * Tests {@link ItemsProvider#getAllItems(Category, int, String[], UserId)} does not return |
| * hidden images/videos. |
| */ |
| @Test |
| public void testGetItemsImages_nonMedia() throws Exception { |
| // Create 1 image and 1 video file in a hidden dir to test |
| // Both should not be returned. |
| File hiddenDir = createHiddenDir(); |
| File imageFileHidden = assertCreateNewImage(hiddenDir); |
| File videoFileHidden = assertCreateNewVideo(hiddenDir); |
| try { |
| final Cursor res = mItemsProvider.getAllItems(Category.DEFAULT, /* limit */ -1, |
| /* mimeType */ new String[]{"image/*"}, /* userId */ null); |
| assertThat(res).isNotNull(); |
| assertThat(res.getCount()).isEqualTo(0); |
| } finally { |
| imageFileHidden.delete(); |
| videoFileHidden.delete(); |
| hiddenDir.delete(); |
| } |
| } |
| |
| /** |
| * Tests {@link ItemsProvider#getAllItems(Category, int, String[], UserId)} to return all |
| * images and videos based on the mimeType. Video mimeType should only return videos. |
| */ |
| @Test |
| public void testGetItemsVideos() throws Exception { |
| // Create 1 image and 1 video file to test |
| // Only 1 should be returned. |
| File imageFile = assertCreateNewImage(); |
| File videoFile = assertCreateNewVideo(); |
| try { |
| final Cursor res = mItemsProvider.getAllItems(Category.DEFAULT, /* limit */ -1, |
| /* mimeType */ new String[]{"video/*"}, /* userId */ null); |
| assertThat(res).isNotNull(); |
| assertThat(res.getCount()).isEqualTo(1); |
| |
| assertThatOnlyVideos(res); |
| assertThatAllVideos(res.getCount()); |
| } finally { |
| imageFile.delete(); |
| videoFile.delete(); |
| } |
| } |
| |
| /** |
| * Tests {@link ItemsProvider#getAllItems(Category, int, String[], UserId)} to return all |
| * images and videos based on the mimeType. Image mimeType should only return images. |
| */ |
| @Test |
| public void testGetItemsVideos_mp4() throws Exception { |
| // Create a mp4 video file. Tests positive use case, this should be returned below. |
| File videoFile = assertCreateNewVideo(); |
| try { |
| final Cursor res = mItemsProvider.getAllItems(Category.DEFAULT, /* limit */ -1, |
| /* mimeType */ new String[]{"video/mp4"}, /* userId */ null); |
| assertThat(res).isNotNull(); |
| assertThat(res.getCount()).isEqualTo(1); |
| } finally { |
| videoFile.delete(); |
| } |
| } |
| |
| /** |
| * Tests {@link ItemsProvider#getAllItems(Category, int, String[], UserId)} does not return |
| * hidden images/videos. |
| */ |
| @Test |
| public void testGetItemsVideos_nonMedia() throws Exception { |
| // Create 1 image and 1 video file in a hidden dir to test the API. |
| // Both should not be returned. |
| File hiddenDir = createHiddenDir(); |
| File imageFileHidden = assertCreateNewImage(hiddenDir); |
| File videoFileHidden = assertCreateNewVideo(hiddenDir); |
| try { |
| final Cursor res = mItemsProvider.getAllItems(Category.DEFAULT, /* limit */ -1, |
| /* mimeType */ new String[]{"video/*"}, /* userId */ null); |
| |
| assertThat(res).isNotNull(); |
| assertThat(res.getCount()).isEqualTo(0); |
| } finally { |
| imageFileHidden.delete(); |
| videoFileHidden.delete(); |
| hiddenDir.delete(); |
| } |
| } |
| |
| /** |
| * Tests {@link ItemsProvider#getLocalItems(Category, int, String[], UserId)} to returns only |
| * local content. |
| */ |
| @Test |
| public void testGetLocalItems_withCloud() throws Exception { |
| File videoFile = assertCreateNewVideo(); |
| try { |
| mConfigStore.enableCloudMediaFeatureAndSetAllowedCloudProviderPackages( |
| sTargetPackageName); |
| // Init cloud provider and add one item |
| setupCloudProvider((cloudMediaGenerator) -> { |
| cloudMediaGenerator.addMedia(null, "cloud_id1"); |
| }); |
| |
| // Verify that getLocalItems includes only local contents |
| try (Cursor c = mItemsProvider.getLocalItems(Category.DEFAULT, -1, new String[]{}, |
| UserId.CURRENT_USER)) { |
| assertThat(c.getCount()).isEqualTo(1); |
| |
| assertThat(c.moveToFirst()).isTrue(); |
| assertThat(c.getString(c.getColumnIndexOrThrow(MediaColumns.AUTHORITY))) |
| .isEqualTo(LOCAL_PICKER_PROVIDER_AUTHORITY); |
| } |
| |
| // Verify that getAllItems includes cloud items |
| try (Cursor c = mItemsProvider.getAllItems(Category.DEFAULT, -1, new String[]{}, |
| UserId.CURRENT_USER)) { |
| assertThat(c.getCount()).isEqualTo(2); |
| |
| // Verify that the first item is cloud item |
| assertThat(c.moveToFirst()).isTrue(); |
| assertThat(c.getString(c.getColumnIndexOrThrow(MediaColumns.AUTHORITY))) |
| .isEqualTo(CloudProviderPrimary.AUTHORITY); |
| assertThat(c.getString(c.getColumnIndexOrThrow(MediaColumns.ID))).isEqualTo( |
| "cloud_id1"); |
| |
| // Verify that the second item is local item |
| assertThat(c.moveToNext()).isTrue(); |
| assertThat(c.getString(c.getColumnIndexOrThrow(MediaColumns.AUTHORITY))) |
| .isEqualTo(LOCAL_PICKER_PROVIDER_AUTHORITY); |
| } |
| } finally { |
| videoFile.delete(); |
| setCloudProvider(null); |
| mConfigStore.clearAllowedCloudProviderPackagesAndDisableCloudMediaFeature(); |
| } |
| } |
| |
| @Test |
| public void testGetLocalItems_mergedAlbum_withCloud() throws Exception { |
| File videoFile = assertCreateNewVideo(); |
| Category videoAlbum = new Category(CloudMediaProviderContract.AlbumColumns.ALBUM_ID_VIDEOS, |
| LOCAL_PICKER_PROVIDER_AUTHORITY, "", null, 10, true); |
| try { |
| mConfigStore.enableCloudMediaFeatureAndSetAllowedCloudProviderPackages( |
| sTargetPackageName); |
| // Init cloud provider and add one item |
| setupCloudProvider((cloudMediaGenerator) -> { |
| cloudMediaGenerator.addMedia(null, "cloud_id1", null, "video/mp4", 0, 1024, false); |
| }); |
| |
| // Verify that getLocalItems for merged album "Video" includes only local contents |
| try (Cursor c = mItemsProvider.getLocalItems(videoAlbum, -1, new String[]{}, |
| UserId.CURRENT_USER)) { |
| assertThat(c.getCount()).isEqualTo(1); |
| assertThat(c.moveToFirst()).isTrue(); |
| assertThat(c.getString(c.getColumnIndexOrThrow(MediaColumns.AUTHORITY))) |
| .isEqualTo(LOCAL_PICKER_PROVIDER_AUTHORITY); |
| } |
| |
| // Verify that getAllItems for merged album "Video" also includes cloud contents |
| try (Cursor c = mItemsProvider.getAllItems(videoAlbum, -1, new String[]{}, |
| UserId.CURRENT_USER)) { |
| assertThat(c.getCount()).isEqualTo(2); |
| // Verify that the first item is cloud item |
| assertThat(c.moveToFirst()).isTrue(); |
| assertThat(c.getString(c.getColumnIndexOrThrow(MediaColumns.AUTHORITY))) |
| .isEqualTo(CloudProviderPrimary.AUTHORITY); |
| assertThat(c.getString(c.getColumnIndexOrThrow(MediaColumns.ID))) |
| .isEqualTo("cloud_id1"); |
| |
| // Verify that the second item is local item |
| assertThat(c.moveToNext()).isTrue(); |
| assertThat(c.getString(c.getColumnIndexOrThrow(MediaColumns.AUTHORITY))) |
| .isEqualTo(LOCAL_PICKER_PROVIDER_AUTHORITY); |
| } |
| } finally { |
| videoFile.delete(); |
| setCloudProvider(null); |
| mConfigStore.clearAllowedCloudProviderPackagesAndDisableCloudMediaFeature(); |
| } |
| } |
| |
| @Test |
| public void testGetLocalCategories_withCloud() throws Exception { |
| File videoFile = assertCreateNewVideo(getMoviesDir()); |
| File screenshotFile = assertCreateNewImage(getScreenshotsDir()); |
| final String cloudAlbum = "testAlbum"; |
| |
| try { |
| mConfigStore.enableCloudMediaFeatureAndSetAllowedCloudProviderPackages( |
| sTargetPackageName); |
| // Init cloud provider with 2 items and one cloud album |
| setupCloudProvider((cloudMediaGenerator) -> { |
| cloudMediaGenerator.addMedia(null, "cloud_id1", null, "video/mp4", 0, 1024, false); |
| cloudMediaGenerator.addMedia(null, "cloud_id2", cloudAlbum, "image/jpeg", 0, 1024, |
| false); |
| cloudMediaGenerator.createAlbum(cloudAlbum); |
| }); |
| |
| // Verify that getLocalCategories only returns local albums |
| try (Cursor c = mItemsProvider.getLocalCategories(/* mimeType */ null, |
| /* userId */ null)) { |
| assertGetCategoriesMatchMultiple(c, Arrays.asList( |
| Pair.create(ALBUM_ID_VIDEOS, 1), |
| Pair.create(ALBUM_ID_SCREENSHOTS, 1) |
| )); |
| } |
| |
| |
| // Verify that getAllCategories returns local + cloud albums |
| try (Cursor c = mItemsProvider.getAllCategories(/* mimeType */ null, |
| /* userId */ null)) { |
| assertGetCategoriesMatchMultiple(c, Arrays.asList( |
| Pair.create(ALBUM_ID_VIDEOS, 2), |
| Pair.create(ALBUM_ID_SCREENSHOTS, 1), |
| Pair.create(cloudAlbum, 1) |
| )); |
| } |
| } finally { |
| videoFile.delete(); |
| screenshotFile.delete(); |
| setCloudProvider(null); |
| mConfigStore.clearAllowedCloudProviderPackagesAndDisableCloudMediaFeature(); |
| } |
| } |
| |
| private void setupCloudProvider(Consumer<MediaGenerator> initMedia) { |
| MediaGenerator cloudPrimaryMediaGenerator = |
| PickerProviderMediaGenerator.getMediaGenerator(CloudProviderPrimary.AUTHORITY); |
| cloudPrimaryMediaGenerator.resetAll(); |
| cloudPrimaryMediaGenerator.setMediaCollectionId("COLLECTION_1"); |
| initMedia.accept(cloudPrimaryMediaGenerator); |
| |
| // Set the newly initialized cloud provider. |
| setCloudProvider(CloudProviderPrimary.AUTHORITY); |
| |
| mIsolatedResolver.call(MediaStore.AUTHORITY, MediaStore.SYNC_PROVIDERS_CALL, null, |
| Bundle.EMPTY); |
| } |
| |
| private void setCloudProvider(String authority) { |
| Bundle in = new Bundle(); |
| in.putString(MediaStore.EXTRA_CLOUD_PROVIDER, authority); |
| mIsolatedResolver.call(MediaStore.AUTHORITY, MediaStore.SET_CLOUD_PROVIDER_CALL, null, in); |
| if (authority != null) { |
| assertWithMessage("Expected " + authority + " to be current cloud provider.") |
| .that(MediaStore.isCurrentCloudMediaProviderAuthority(mIsolatedResolver, |
| authority)).isTrue(); |
| } |
| } |
| |
| private void assertGetCategoriesMatchSingle(String expectedCategoryName, |
| int expectedNumberOfItems) throws Exception { |
| if (expectedNumberOfItems == 0) { |
| assertCategoriesNoMatch(expectedCategoryName); |
| return; |
| } |
| |
| Cursor c = mItemsProvider.getAllCategories(/* mimeType */ null, /* userId */ null); |
| assertThat(c).isNotNull(); |
| assertThat(c.getCount()).isEqualTo(1); |
| |
| // Assert that only expected category is returned and has expectedNumberOfItems items in it |
| assertThat(c.moveToFirst()).isTrue(); |
| final int nameColumnIndex = c.getColumnIndexOrThrow(AlbumColumns.DISPLAY_NAME); |
| final int numOfItemsColumnIndex = c.getColumnIndexOrThrow(AlbumColumns.MEDIA_COUNT); |
| final int coverIdIndex = c.getColumnIndexOrThrow(AlbumColumns.MEDIA_COVER_ID); |
| |
| final String categoryName = c.getString(nameColumnIndex); |
| final int numOfItems = c.getInt(numOfItemsColumnIndex); |
| final Uri coverUri = ItemsProvider.getItemsUri(c.getString(coverIdIndex), |
| LOCAL_PICKER_PROVIDER_AUTHORITY, UserId.CURRENT_USER); |
| |
| assertThat(categoryName).isEqualTo(expectedCategoryName); |
| assertThat(numOfItems).isEqualTo(expectedNumberOfItems); |
| assertCategoryUriIsValid(coverUri); |
| } |
| |
| private void assertCategoryUriIsValid(Uri uri) throws Exception { |
| try (AssetFileDescriptor fd1 = mIsolatedResolver.openTypedAssetFile(uri, "image/*", |
| null, null)) { |
| assertThat(fd1).isNotNull(); |
| } |
| try (ParcelFileDescriptor fd2 = mIsolatedResolver.openFileDescriptor(uri, "r")) { |
| assertThat(fd2).isNotNull(); |
| } |
| } |
| |
| private void assertCategoriesNoMatch(String expectedCategoryName) { |
| try (Cursor c = mItemsProvider.getAllCategories(/* mimeType */ null, /* userId */ null)) { |
| while (c != null && c.moveToNext()) { |
| final int nameColumnIndex = c.getColumnIndexOrThrow(AlbumColumns.DISPLAY_NAME); |
| final String categoryName = c.getString(nameColumnIndex); |
| assertThat(categoryName).isNotEqualTo(expectedCategoryName); |
| } |
| } |
| } |
| |
| private void assertGetCategoriesMatchMultiple(List<Pair<String, Integer>> categories) { |
| try (Cursor c = mItemsProvider.getAllCategories(/* mimeType */ null, /* userId */ null)) { |
| assertGetCategoriesMatchMultiple(c, categories); |
| } |
| } |
| |
| private void assertGetCategoriesMatchMultiple(Cursor c, |
| List<Pair<String, Integer>> categories) { |
| assertThat(c).isNotNull(); |
| assertWithMessage("Expected number of albums") |
| .that(c.getCount()).isEqualTo(categories.size()); |
| |
| final int nameColumnIndex = c.getColumnIndexOrThrow(AlbumColumns.DISPLAY_NAME); |
| final int numOfItemsColumnIndex = c.getColumnIndexOrThrow( |
| AlbumColumns.MEDIA_COUNT); |
| for (Pair<String, Integer> category : categories) { |
| c.moveToNext(); |
| |
| assertThat(category.first).isEqualTo(c.getString(nameColumnIndex)); |
| assertWithMessage("Expected item count for " + category.first).that( |
| c.getInt(numOfItemsColumnIndex)).isEqualTo(category.second); |
| } |
| } |
| |
| private void setIsFavorite(File file) { |
| final Uri uri = MediaStore.scanFile(mIsolatedResolver, file); |
| final ContentValues values = new ContentValues(); |
| values.put(MediaStore.MediaColumns.IS_FAVORITE, 1); |
| // Assert that 1 row corresponding to this file is updated. |
| assertThat(mIsolatedResolver.update(uri, values, null)).isEqualTo(1); |
| // Wait for MediaStore to be Idle to reduce flakes caused by database updates |
| MediaStore.waitForIdle(mIsolatedResolver); |
| } |
| |
| private void assertThatOnlyImagesVideos(Cursor c) throws Exception { |
| while (c.moveToNext()) { |
| int mimeTypeColumn = c.getColumnIndexOrThrow(MediaStore.MediaColumns.MIME_TYPE); |
| String mimeType = c.getString(mimeTypeColumn); |
| assertThat(isImageMimeType(mimeType) || isVideoMimeType(mimeType)).isTrue(); |
| } |
| } |
| |
| private void assertThatOnlyImages(Cursor c) throws Exception { |
| while (c.moveToNext()) { |
| int mimeTypeColumn = c.getColumnIndexOrThrow(MediaStore.MediaColumns.MIME_TYPE); |
| String mimeType = c.getString(mimeTypeColumn); |
| assertThat(isImageMimeType(mimeType)).isTrue(); |
| } |
| } |
| |
| private void assertThatOnlyVideos(Cursor c) throws Exception { |
| while (c.moveToNext()) { |
| int mimeTypeColumn = c.getColumnIndexOrThrow(MediaStore.MediaColumns.MIME_TYPE); |
| String mimeType = c.getString(mimeTypeColumn); |
| assertThat(isVideoMimeType(mimeType)).isTrue(); |
| } |
| } |
| |
| private void assertThatAllImagesVideos(int count) { |
| int countOfImages = getCountOfMediaStoreImages(); |
| int countOfVideos = getCountOfMediaStoreVideos(); |
| assertThat(count).isEqualTo(countOfImages + countOfVideos); |
| } |
| |
| private void assertThatAllImages(int count) { |
| int countOfImages = getCountOfMediaStoreImages(); |
| assertThat(count).isEqualTo(countOfImages); |
| } |
| |
| private void assertThatAllVideos(int count) { |
| int countOfVideos = getCountOfMediaStoreVideos(); |
| assertThat(count).isEqualTo(countOfVideos); |
| } |
| |
| private void createTestScreenshotImages() throws IOException { |
| // Top Level /Screenshots/ directory is not allowed by MediaProvider, so the directory |
| // and test files in it are created via shell commands. |
| |
| final String createTopLevelScreenshotDirCommand = |
| "mkdir -p " |
| + Environment.getExternalStorageDirectory().getPath() |
| + "/" |
| + Environment.DIRECTORY_SCREENSHOTS; |
| final String createTopLevelScreenshotImgCommand = |
| "touch " + getTopLevelScreenshotsDir().getPath() + "/" + IMAGE_FILE_NAME; |
| final String writeDataTopLevelScreenshotImgCommand = |
| "echo 1 > " + getTopLevelScreenshotsDir().getPath() + "/" + IMAGE_FILE_NAME; |
| |
| executeShellCommand(createTopLevelScreenshotDirCommand); |
| executeShellCommand(createTopLevelScreenshotImgCommand); |
| // Writes 1 byte to the file. |
| executeShellCommand(writeDataTopLevelScreenshotImgCommand); |
| |
| final File topLevelScreenshotsDirImage = |
| new File(getTopLevelScreenshotsDir(), IMAGE_FILE_NAME); |
| |
| // Force the mock MediaProvider to scan. |
| final Uri uri = MediaStore.scanFile(mIsolatedResolver, topLevelScreenshotsDirImage); |
| assertWithMessage("Uri obtained by scanning file " + topLevelScreenshotsDirImage) |
| .that(uri) |
| .isNotNull(); |
| // Wait for picker db sync |
| MediaStore.waitForIdle(mIsolatedResolver); |
| } |
| |
| private int getCountOfMediaStoreImages() { |
| try (Cursor c = mIsolatedResolver.query( |
| MediaStore.Images.Media.getContentUri(VOLUME_EXTERNAL), null, null, null)) { |
| assertThat(c.moveToFirst()).isTrue(); |
| return c.getCount(); |
| } |
| } |
| |
| private int getCountOfMediaStoreVideos() { |
| try (Cursor c = mIsolatedResolver.query( |
| MediaStore.Video.Media.getContentUri(VOLUME_EXTERNAL), null, null, null)) { |
| assertThat(c.moveToFirst()).isTrue(); |
| return c.getCount(); |
| } |
| } |
| |
| private File assertCreateNewVideo(File dir) throws Exception { |
| return assertCreateNewFile(dir, VIDEO_FILE_NAME); |
| } |
| |
| private File assertCreateNewImage(File dir) throws Exception { |
| return assertCreateNewFile(dir, IMAGE_FILE_NAME); |
| } |
| |
| private File assertCreateNewVideo() throws Exception { |
| return assertCreateNewFile(getDownloadsDir(), VIDEO_FILE_NAME); |
| } |
| |
| private File assertCreateNewImage() throws Exception { |
| return assertCreateNewFile(getDownloadsDir(), IMAGE_FILE_NAME); |
| } |
| |
| private File assertCreateNewFile(File parentDir, String fileName) throws Exception { |
| final File file = new File(parentDir, fileName); |
| prepareFileAndGetUri(file, /* lastModifiedTime */ -1); |
| |
| return file; |
| } |
| |
| private Uri prepareFileAndGetUri(File file, long lastModifiedTime) throws IOException { |
| ensureParentExists(file.getParentFile()); |
| |
| assertThat(file.createNewFile()).isTrue(); |
| |
| // Write 1 byte because 0byte files are not valid in the picker db |
| try (FileOutputStream fos = new FileOutputStream(file)) { |
| fos.write(1); |
| } |
| |
| if (lastModifiedTime != -1) { |
| file.setLastModified(lastModifiedTime); |
| } |
| |
| final Uri uri = MediaStore.scanFile(mIsolatedResolver, file); |
| assertWithMessage("Uri obtained by scanning file " + file) |
| .that(uri).isNotNull(); |
| // Wait for picker db sync |
| MediaStore.waitForIdle(mIsolatedResolver); |
| |
| return uri; |
| } |
| |
| private void ensureParentExists(File parent) { |
| if (!parent.exists()) { |
| parent.mkdirs(); |
| } |
| assertThat(parent.exists()).isTrue(); |
| } |
| |
| private File getDownloadsDir() { |
| return new File(Environment.getExternalStorageDirectory(), Environment.DIRECTORY_DOWNLOADS); |
| } |
| |
| private File getDcimDir() { |
| return new File(Environment.getExternalStorageDirectory(), Environment.DIRECTORY_DCIM); |
| } |
| |
| private File getPicturesDir() { |
| return new File(Environment.getExternalStorageDirectory(), Environment.DIRECTORY_PICTURES); |
| } |
| |
| private File getMoviesDir() { |
| return new File(Environment.getExternalStorageDirectory(), Environment.DIRECTORY_MOVIES); |
| } |
| |
| private File getCameraDir() { |
| return new File(getDcimDir(), "Camera"); |
| } |
| |
| private File getScreenshotsDir() { |
| return new File(getPicturesDir(), Environment.DIRECTORY_SCREENSHOTS); |
| } |
| |
| private File getTopLevelScreenshotsDir() { |
| return new File( |
| Environment.getExternalStorageDirectory(), Environment.DIRECTORY_SCREENSHOTS); |
| } |
| |
| private File getScreenshotsDirFromDownloadsDir() { |
| return new File(getDownloadsDir(), Environment.DIRECTORY_SCREENSHOTS); |
| } |
| |
| private File createHiddenDir() throws Exception { |
| File parentDir = new File(Environment.getExternalStorageDirectory(), |
| Environment.DIRECTORY_DOWNLOADS); |
| File dir = new File(parentDir, HIDDEN_DIR_NAME); |
| dir.mkdirs(); |
| File nomedia = new File(dir, ".nomedia"); |
| nomedia.createNewFile(); |
| |
| MediaStore.scanFile(mIsolatedResolver, nomedia); |
| |
| return dir; |
| } |
| |
| private void deleteAllFilesNoThrow() { |
| try (Cursor c = mIsolatedResolver.query( |
| MediaStore.Files.getContentUri(VOLUME_EXTERNAL), |
| new String[] {MediaStore.MediaColumns.DATA}, null, null)) { |
| while(c.moveToNext()) { |
| (new File(c.getString( |
| c.getColumnIndexOrThrow(MediaStore.MediaColumns.DATA)))).delete(); |
| } |
| } |
| } |
| |
| private void deleteTopLevelScreenshotDir() throws IOException { |
| final String removeTopLevelScreenshotDirCommand = |
| "rm -rf " + getTopLevelScreenshotsDir().getPath(); |
| executeShellCommand(removeTopLevelScreenshotDirCommand); |
| } |
| |
| /** Executes a shell command. */ |
| private static String executeShellCommand(String command) throws IOException { |
| int attempt = 0; |
| while (attempt++ < 5) { |
| try { |
| return executeShellCommandInternal(command); |
| } catch (InterruptedIOException e) { |
| Log.v(TAG, "Trouble executing " + command + "; trying again", e); |
| } |
| } |
| throw new IOException("Failed to execute " + command); |
| } |
| |
| private static String executeShellCommandInternal(String cmd) throws IOException { |
| UiAutomation uiAutomation = InstrumentationRegistry.getInstrumentation().getUiAutomation(); |
| try (FileInputStream output = new FileInputStream( |
| uiAutomation.executeShellCommand(cmd).getFileDescriptor())) { |
| return new String(ByteStreams.toByteArray(output)); |
| } |
| } |
| } |
