| /* |
| * Copyright (C) 2016 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 androidx.leanback.app; |
| |
| import static org.junit.Assert.assertEquals; |
| import static org.junit.Assert.assertNull; |
| import static org.junit.Assert.assertSame; |
| import static org.junit.Assert.assertTrue; |
| |
| import android.content.Intent; |
| import android.graphics.Bitmap; |
| import android.graphics.Canvas; |
| import android.graphics.Color; |
| import android.graphics.Paint; |
| import android.graphics.drawable.BitmapDrawable; |
| import android.graphics.drawable.ColorDrawable; |
| import android.graphics.drawable.Drawable; |
| import android.os.Bundle; |
| import android.support.test.filters.LargeTest; |
| import android.support.test.runner.AndroidJUnit4; |
| |
| import androidx.leanback.testutils.PollingCheck; |
| |
| import org.junit.Rule; |
| import org.junit.Test; |
| import org.junit.rules.TestName; |
| import org.junit.runner.RunWith; |
| |
| @LargeTest |
| @RunWith(AndroidJUnit4.class) |
| public class BackgroundManagerTest { |
| |
| @Rule |
| public TestName mUnitTestName = new TestName(); |
| |
| @Rule |
| public TestActivity.TestActivityTestRule mRule; |
| |
| String generateProviderName(String name) { |
| return mUnitTestName.getMethodName() + "_" + name; |
| } |
| |
| void waitForActivityStop(final TestActivity activity) { |
| PollingCheck.waitFor(5000/* timeout */, new PollingCheck.PollingCheckCondition() { |
| @Override |
| public boolean canPreProceed() { |
| return false; |
| } |
| |
| @Override |
| public boolean canProceed() { |
| // two step: first ChangeRunnable gets run. |
| // then Animator is finished. |
| return !activity.isStarted(); |
| } |
| }); |
| } |
| |
| void waitForBackgroundAnimationFinish(final BackgroundManager manager) { |
| PollingCheck.waitFor(5000/* timeout */, new PollingCheck.PollingCheckCondition() { |
| @Override |
| public boolean canPreProceed() { |
| return false; |
| } |
| |
| @Override |
| public boolean canProceed() { |
| // two step: first ChangeRunnable gets run. |
| // then Animator is finished. |
| return manager.mLayerDrawable != null && manager.mChangeRunnable == null |
| && !manager.mAnimator.isRunning(); |
| } |
| }); |
| } |
| |
| void setBitmapAndVerify(final BackgroundManager manager, final Bitmap bitmap) |
| throws Throwable { |
| mRule.runOnUiThread(new Runnable() { |
| @Override |
| public void run() { |
| manager.setBitmap(bitmap); |
| } |
| }); |
| waitForBackgroundAnimationFinish(manager); |
| assertIsBitmapDrawable(manager, bitmap); |
| } |
| |
| void setDrawableAndVerify(final BackgroundManager manager, final Drawable drawable) |
| throws Throwable { |
| mRule.runOnUiThread(new Runnable() { |
| @Override |
| public void run() { |
| manager.setDrawable(drawable); |
| } |
| }); |
| waitForBackgroundAnimationFinish(manager); |
| assertIsDrawable(manager, drawable); |
| } |
| |
| void setBitmapNullAndVerifyColor(final BackgroundManager manager, final int color) |
| throws Throwable { |
| mRule.runOnUiThread(new Runnable() { |
| @Override |
| public void run() { |
| manager.setBitmap(null); |
| } |
| }); |
| waitForBackgroundAnimationFinish(manager); |
| assertIsColorDrawable(manager, color); |
| } |
| |
| void setDrawableNullAndVerifyColor(final BackgroundManager manager, final int color) |
| throws Throwable { |
| mRule.runOnUiThread(new Runnable() { |
| @Override |
| public void run() { |
| manager.setDrawable(null); |
| } |
| }); |
| waitForBackgroundAnimationFinish(manager); |
| assertIsColorDrawable(manager, color); |
| } |
| |
| void setColorAndVerify(final BackgroundManager manager, final int color) |
| throws Throwable { |
| mRule.runOnUiThread(new Runnable() { |
| @Override |
| public void run() { |
| manager.setColor(color); |
| } |
| }); |
| waitForBackgroundAnimationFinish(manager); |
| assertIsColorDrawable(manager, color); |
| } |
| |
| /** |
| * Launch TestActivity without using TestActivityRule. |
| */ |
| TestActivity launchActivity(String name, final TestActivity.Provider provider2) |
| throws Throwable { |
| final String providerName2 = generateProviderName(name); |
| TestActivity.setProvider(providerName2, provider2); |
| mRule.runOnUiThread(new Runnable() { |
| @Override |
| public void run() { |
| Intent intent = new Intent(mRule.getActivity(), TestActivity.class); |
| intent.putExtra(TestActivity.EXTRA_PROVIDER, providerName2); |
| mRule.getActivity().startActivity(intent); |
| } |
| }); |
| |
| PollingCheck.waitFor(5000/*timeout*/, new PollingCheck.PollingCheckCondition() { |
| @Override |
| public boolean canPreProceed() { |
| return false; |
| } |
| |
| @Override |
| public boolean canProceed() { |
| return provider2.getActivity() != null && provider2.getActivity().isStarted(); |
| } |
| }); |
| return provider2.getActivity(); |
| } |
| |
| void assertIsColorDrawable(BackgroundManager manager, int color) { |
| assertNull(manager.mLayerDrawable.mWrapper[0]); |
| assertTrue(manager.mLayerDrawable.getDrawable(0) |
| instanceof BackgroundManager.EmptyDrawable); |
| assertEquals(manager.mLayerDrawable.mWrapper[1].mAlpha, 255); |
| assertEquals(((ColorDrawable) manager.mLayerDrawable.getDrawable(1)).getColor(), color); |
| assertNull(manager.mBackgroundDrawable); |
| } |
| |
| void assertIsBitmapDrawable(BackgroundManager manager, Bitmap bitmap) { |
| assertNull(manager.mLayerDrawable.mWrapper[0]); |
| assertTrue(manager.mLayerDrawable.getDrawable(0) |
| instanceof BackgroundManager.EmptyDrawable); |
| assertEquals(manager.mLayerDrawable.mWrapper[1].mAlpha, 255); |
| assertSame(((BackgroundManager.BitmapDrawable) manager.mLayerDrawable.getDrawable(1)) |
| .mState.mBitmap, bitmap); |
| assertSame(((BackgroundManager.BitmapDrawable) manager.mBackgroundDrawable) |
| .mState.mBitmap, bitmap); |
| } |
| |
| void assertIsDrawable(BackgroundManager manager, Drawable drawable) { |
| assertNull(manager.mLayerDrawable.mWrapper[0]); |
| assertTrue(manager.mLayerDrawable.getDrawable(0) |
| instanceof BackgroundManager.EmptyDrawable); |
| assertEquals(manager.mLayerDrawable.mWrapper[1].mAlpha, 255); |
| assertSame(manager.mLayerDrawable.getDrawable(1), drawable); |
| assertSame(manager.mBackgroundDrawable, drawable); |
| } |
| |
| Bitmap createBitmap(int width, int height, int color) { |
| final Bitmap bitmap = Bitmap.createBitmap(width, height, Bitmap.Config.ARGB_8888); |
| Canvas canvas = new Canvas(bitmap); |
| Paint paint = new Paint(); |
| paint.setColor(color); |
| canvas.drawRect(0, 0, width, height, paint); |
| return bitmap; |
| } |
| |
| Drawable createDrawable(int width, int height, int color) { |
| final Bitmap bitmap = Bitmap.createBitmap(width, height, Bitmap.Config.ARGB_8888); |
| Canvas canvas = new Canvas(bitmap); |
| Paint paint = new Paint(); |
| paint.setColor(color); |
| canvas.drawRect(0, 0, width, height, paint); |
| return new BitmapDrawable(mRule.getActivity().getResources(), bitmap); |
| } |
| |
| void testSwitchBackgrounds(final BackgroundManager manager) throws Throwable { |
| setBitmapAndVerify(manager, createBitmap(200, 100, Color.GREEN)); |
| |
| // Drawable -> Drawable |
| setDrawableAndVerify(manager, createDrawable(200, 100, Color.MAGENTA)); |
| |
| setBitmapAndVerify(manager, createBitmap(200, 100, Color.GRAY)); |
| |
| // Drawable -> Color |
| setColorAndVerify(manager, Color.RED); |
| |
| // Color -> Drawable |
| setBitmapAndVerify(manager, createBitmap(200, 100, Color.BLACK)); |
| |
| // Set Drawable to null -> show last Color |
| setBitmapNullAndVerifyColor(manager, Color.RED); |
| |
| // Color -> Drawable |
| setBitmapAndVerify(manager, createBitmap(200, 100, Color.MAGENTA)); |
| } |
| |
| @Test |
| public void establishInOnAttachToWindow() throws Throwable { |
| TestActivity.Provider provider1 = new TestActivity.Provider() { |
| @Override |
| public void onAttachedToWindow(TestActivity activity) { |
| BackgroundManager.getInstance(activity).attach(activity.getWindow()); |
| } |
| |
| @Override |
| public void onStart(TestActivity activity) { |
| BackgroundManager.getInstance(activity).setColor(Color.BLUE); |
| } |
| }; |
| mRule = new TestActivity.TestActivityTestRule(provider1, generateProviderName("activity1")); |
| final TestActivity activity1 = mRule.launchActivity(); |
| |
| BackgroundManager manager = BackgroundManager.getInstance(activity1); |
| waitForBackgroundAnimationFinish(manager); |
| assertIsColorDrawable(manager, Color.BLUE); |
| |
| testSwitchBackgrounds(manager); |
| } |
| |
| @Test |
| public void multipleSetBitmaps() throws Throwable { |
| TestActivity.Provider provider1 = new TestActivity.Provider() { |
| @Override |
| public void onAttachedToWindow(TestActivity activity) { |
| BackgroundManager.getInstance(activity).attach(activity.getWindow()); |
| } |
| |
| @Override |
| public void onStart(TestActivity activity) { |
| BackgroundManager.getInstance(activity).setColor(Color.BLUE); |
| } |
| }; |
| mRule = new TestActivity.TestActivityTestRule(provider1, |
| generateProviderName("activity1")); |
| final TestActivity activity1 = mRule.launchActivity(); |
| |
| final BackgroundManager manager = BackgroundManager.getInstance(activity1); |
| waitForBackgroundAnimationFinish(manager); |
| assertIsColorDrawable(manager, Color.BLUE); |
| |
| final Bitmap bitmap1 = createBitmap(200, 100, Color.RED); |
| final Bitmap bitmap2 = createBitmap(200, 100, Color.GRAY); |
| final Bitmap bitmap3 = createBitmap(200, 100, Color.GREEN); |
| final Bitmap bitmap4 = createBitmap(200, 100, Color.MAGENTA); |
| mRule.runOnUiThread(new Runnable() { |
| @Override |
| public void run() { |
| manager.setBitmap(bitmap1); |
| manager.setBitmap(bitmap2); |
| manager.setBitmap(bitmap3); |
| manager.setBitmap(bitmap4); |
| } |
| }); |
| waitForBackgroundAnimationFinish(manager); |
| assertIsBitmapDrawable(manager, bitmap4); |
| } |
| |
| @Test |
| public void multipleSetBitmapsAndColor() throws Throwable { |
| TestActivity.Provider provider1 = new TestActivity.Provider() { |
| @Override |
| public void onAttachedToWindow(TestActivity activity) { |
| BackgroundManager.getInstance(activity).attach(activity.getWindow()); |
| } |
| |
| @Override |
| public void onStart(TestActivity activity) { |
| BackgroundManager.getInstance(activity).setColor(Color.BLUE); |
| } |
| }; |
| mRule = new TestActivity.TestActivityTestRule(provider1, generateProviderName("activity1")); |
| final TestActivity activity1 = mRule.launchActivity(); |
| |
| final BackgroundManager manager = BackgroundManager.getInstance(activity1); |
| waitForBackgroundAnimationFinish(manager); |
| assertIsColorDrawable(manager, Color.BLUE); |
| |
| final Bitmap bitmap1 = createBitmap(200, 100, Color.RED); |
| final Bitmap bitmap2 = createBitmap(200, 100, Color.GRAY); |
| final Bitmap bitmap3 = createBitmap(200, 100, Color.GREEN); |
| final int color = Color.MAGENTA; |
| mRule.runOnUiThread(new Runnable() { |
| @Override |
| public void run() { |
| manager.setBitmap(bitmap1); |
| manager.setBitmap(bitmap2); |
| } |
| }); |
| mRule.runOnUiThread(new Runnable() { |
| @Override |
| public void run() { |
| manager.setBitmap(bitmap3); |
| manager.setColor(color); |
| } |
| }); |
| waitForBackgroundAnimationFinish(manager); |
| assertIsColorDrawable(manager, color); |
| } |
| |
| @Test |
| public void establishInOnCreate() throws Throwable { |
| TestActivity.Provider provider1 = new TestActivity.Provider() { |
| @Override |
| public void onCreate(TestActivity activity, Bundle savedInstanceState) { |
| super.onCreate(activity, savedInstanceState); |
| BackgroundManager.getInstance(activity).attach(activity.getWindow()); |
| } |
| |
| @Override |
| public void onStart(TestActivity activity) { |
| BackgroundManager.getInstance(activity).setColor(Color.BLUE); |
| } |
| }; |
| mRule = new TestActivity.TestActivityTestRule(provider1, generateProviderName("activity1")); |
| final TestActivity activity1 = mRule.launchActivity(); |
| |
| BackgroundManager manager = BackgroundManager.getInstance(activity1); |
| waitForBackgroundAnimationFinish(manager); |
| assertIsColorDrawable(manager, Color.BLUE); |
| |
| testSwitchBackgrounds(manager); |
| } |
| |
| @Test |
| public void establishInOnStart() throws Throwable { |
| TestActivity.Provider provider1 = new TestActivity.Provider() { |
| @Override |
| public void onStart(TestActivity activity) { |
| BackgroundManager m = BackgroundManager.getInstance(activity); |
| if (!m.isAttached()) { |
| // onStart will be called mutliple times, attach() can only be called once. |
| m.attach(activity.getWindow()); |
| } |
| m.setColor(Color.BLUE); |
| } |
| }; |
| mRule = new TestActivity.TestActivityTestRule(provider1, generateProviderName("activity1")); |
| final TestActivity activity1 = mRule.launchActivity(); |
| |
| BackgroundManager manager = BackgroundManager.getInstance(activity1); |
| waitForBackgroundAnimationFinish(manager); |
| assertIsColorDrawable(manager, Color.BLUE); |
| |
| testSwitchBackgrounds(manager); |
| } |
| |
| @Test |
| public void assignColorImmediately() throws Throwable { |
| TestActivity.Provider provider1 = new TestActivity.Provider() { |
| @Override |
| public void onCreate(TestActivity activity, Bundle savedInstanceState) { |
| super.onCreate(activity, savedInstanceState); |
| BackgroundManager m = BackgroundManager.getInstance(activity); |
| // if we set color before attach, it will be assigned immediately |
| m.setColor(Color.BLUE); |
| m.attach(activity.getWindow()); |
| assertIsColorDrawable(m, Color.BLUE); |
| } |
| }; |
| mRule = new TestActivity.TestActivityTestRule(provider1, generateProviderName("activity1")); |
| final TestActivity activity1 = mRule.launchActivity(); |
| |
| BackgroundManager manager = BackgroundManager.getInstance(activity1); |
| |
| testSwitchBackgrounds(manager); |
| } |
| |
| @Test |
| public void assignBitmapImmediately() throws Throwable { |
| final Bitmap bitmap = createBitmap(200, 100, Color.BLUE); |
| TestActivity.Provider provider1 = new TestActivity.Provider() { |
| @Override |
| public void onCreate(TestActivity activity, Bundle savedInstanceState) { |
| super.onCreate(activity, savedInstanceState); |
| BackgroundManager m = BackgroundManager.getInstance(activity); |
| // if we set bitmap before attach, it will be assigned immediately |
| m.setBitmap(bitmap); |
| m.attach(activity.getWindow()); |
| assertIsBitmapDrawable(m, bitmap); |
| } |
| }; |
| mRule = new TestActivity.TestActivityTestRule(provider1, generateProviderName("activity1")); |
| final TestActivity activity1 = mRule.launchActivity(); |
| |
| BackgroundManager manager = BackgroundManager.getInstance(activity1); |
| |
| testSwitchBackgrounds(manager); |
| } |
| |
| |
| @Test |
| public void inheritBitmapByNewActivity() throws Throwable { |
| final Bitmap bitmap = createBitmap(200, 100, Color.BLUE); |
| TestActivity.Provider provider1 = new TestActivity.Provider() { |
| @Override |
| public void onCreate(TestActivity activity, Bundle savedInstanceState) { |
| super.onCreate(activity, savedInstanceState); |
| BackgroundManager m = BackgroundManager.getInstance(activity); |
| // if we set bitmap before attach, it will be assigned immediately |
| m.setBitmap(bitmap); |
| m.attach(activity.getWindow()); |
| assertIsBitmapDrawable(m, bitmap); |
| } |
| }; |
| mRule = new TestActivity.TestActivityTestRule(provider1, generateProviderName("activity1")); |
| final TestActivity activity1 = mRule.launchActivity(); |
| |
| TestActivity.Provider provider2 = new TestActivity.Provider() { |
| @Override |
| public void onCreate(TestActivity activity, Bundle savedInstanceState) { |
| super.onCreate(activity, savedInstanceState); |
| BackgroundManager m = BackgroundManager.getInstance(activity); |
| m.attach(activity.getWindow()); |
| assertIsBitmapDrawable(m, bitmap); |
| } |
| }; |
| |
| TestActivity activity2 = launchActivity("activity2", provider2); |
| waitForActivityStop(activity1); |
| |
| BackgroundManager manager2 = BackgroundManager.getInstance(activity2); |
| assertIsBitmapDrawable(manager2, bitmap); |
| activity2.finish(); |
| } |
| |
| @Test |
| public void inheritColorByNewActivity() throws Throwable { |
| final int color = Color.BLUE; |
| TestActivity.Provider provider1 = new TestActivity.Provider() { |
| @Override |
| public void onCreate(TestActivity activity, Bundle savedInstanceState) { |
| super.onCreate(activity, savedInstanceState); |
| BackgroundManager m = BackgroundManager.getInstance(activity); |
| // if we set color before attach, it will be assigned immediately |
| m.setColor(color); |
| m.attach(activity.getWindow()); |
| assertIsColorDrawable(m, color); |
| } |
| }; |
| mRule = new TestActivity.TestActivityTestRule(provider1, generateProviderName("activity1")); |
| final TestActivity activity1 = mRule.launchActivity(); |
| |
| TestActivity.Provider provider2 = new TestActivity.Provider() { |
| @Override |
| public void onCreate(TestActivity activity, Bundle savedInstanceState) { |
| super.onCreate(activity, savedInstanceState); |
| BackgroundManager m = BackgroundManager.getInstance(activity); |
| m.attach(activity.getWindow()); |
| assertIsColorDrawable(m, color); |
| } |
| }; |
| TestActivity activity2 = launchActivity("activity2", provider2); |
| waitForActivityStop(activity1); |
| |
| BackgroundManager manager2 = BackgroundManager.getInstance(activity2); |
| assertIsColorDrawable(manager2, color); |
| activity2.finish(); |
| } |
| |
| @Test |
| public void returnFromNewActivity() throws Throwable { |
| final int color = Color.RED; |
| final Bitmap bitmap = createBitmap(200, 100, Color.BLUE); |
| TestActivity.Provider provider1 = new TestActivity.Provider() { |
| @Override |
| public void onCreate(TestActivity activity, Bundle savedInstanceState) { |
| super.onCreate(activity, savedInstanceState); |
| BackgroundManager m = BackgroundManager.getInstance(activity); |
| // if we set bitmap before attach, it will be assigned immediately |
| m.setColor(color); |
| m.setBitmap(bitmap); |
| m.attach(activity.getWindow()); |
| assertIsBitmapDrawable(m, bitmap); |
| } |
| |
| }; |
| mRule = new TestActivity.TestActivityTestRule(provider1, generateProviderName("activity1")); |
| final TestActivity activity1 = mRule.launchActivity(); |
| final BackgroundManager manager1 = BackgroundManager.getInstance(activity1); |
| |
| TestActivity.Provider provider2 = new TestActivity.Provider() { |
| @Override |
| public void onCreate(TestActivity activity, Bundle savedInstanceState) { |
| super.onCreate(activity, savedInstanceState); |
| BackgroundManager m = BackgroundManager.getInstance(activity); |
| m.attach(activity.getWindow()); |
| assertIsBitmapDrawable(m, bitmap); |
| } |
| }; |
| TestActivity activity2 = launchActivity("activity2", provider2); |
| waitForActivityStop(activity1); |
| final BackgroundManager manager2 = BackgroundManager.getInstance(activity2); |
| |
| final Bitmap bitmap2 = createBitmap(200, 100, Color.GREEN); |
| setBitmapAndVerify(manager2, bitmap2); |
| |
| // after activity2 is launched, activity will lose its bitmap and released LayerDrawable |
| assertNull(manager1.mBackgroundDrawable); |
| assertNull(manager1.mLayerDrawable); |
| |
| activity2.finish(); |
| |
| // when return from the other app, last drawable is cleared. |
| waitForBackgroundAnimationFinish(manager1); |
| assertIsColorDrawable(manager1, color); |
| } |
| |
| @Test |
| public void manuallyReleaseInOnStop() throws Throwable { |
| final int color = Color.RED; |
| final Bitmap bitmap = createBitmap(200, 100, Color.BLUE); |
| TestActivity.Provider provider1 = new TestActivity.Provider() { |
| @Override |
| public void onCreate(TestActivity activity, Bundle savedInstanceState) { |
| super.onCreate(activity, savedInstanceState); |
| BackgroundManager m = BackgroundManager.getInstance(activity); |
| m.setAutoReleaseOnStop(false); |
| // if we set bitmap before attach, it will be assigned immediately |
| m.setColor(color); |
| m.setBitmap(bitmap); |
| m.attach(activity.getWindow()); |
| assertIsBitmapDrawable(m, bitmap); |
| } |
| |
| @Override |
| public void onStop(TestActivity activity) { |
| BackgroundManager.getInstance(activity).release(); |
| } |
| }; |
| mRule = new TestActivity.TestActivityTestRule(provider1, generateProviderName("activity1")); |
| final TestActivity activity1 = mRule.launchActivity(); |
| final BackgroundManager manager1 = BackgroundManager.getInstance(activity1); |
| |
| TestActivity.Provider provider2 = new TestActivity.Provider() { |
| @Override |
| public void onCreate(TestActivity activity, Bundle savedInstanceState) { |
| super.onCreate(activity, savedInstanceState); |
| BackgroundManager m = BackgroundManager.getInstance(activity); |
| m.attach(activity.getWindow()); |
| assertIsBitmapDrawable(m, bitmap); |
| } |
| }; |
| TestActivity activity2 = launchActivity("activity2", provider2); |
| waitForActivityStop(activity1); |
| final BackgroundManager manager2 = BackgroundManager.getInstance(activity2); |
| |
| final Bitmap bitmap2 = createBitmap(200, 100, Color.GREEN); |
| setBitmapAndVerify(manager2, bitmap2); |
| |
| // after activity2 is launched, activity will lose its bitmap and released LayerDrawable |
| assertNull(manager1.mBackgroundDrawable); |
| assertNull(manager1.mLayerDrawable); |
| |
| activity2.finish(); |
| |
| // when return from the other app, last drawable is cleared. |
| waitForBackgroundAnimationFinish(manager1); |
| assertIsColorDrawable(manager1, color); |
| } |
| |
| @Test |
| public void disableAutoRelease() throws Throwable { |
| final int color = Color.RED; |
| final Bitmap bitmap = createBitmap(200, 100, Color.BLUE); |
| TestActivity.Provider provider1 = new TestActivity.Provider() { |
| @Override |
| public void onCreate(TestActivity activity, Bundle savedInstanceState) { |
| super.onCreate(activity, savedInstanceState); |
| BackgroundManager m = BackgroundManager.getInstance(activity); |
| m.setAutoReleaseOnStop(false); |
| // if we set bitmap before attach, it will be assigned immediately |
| m.setColor(color); |
| m.setBitmap(bitmap); |
| m.attach(activity.getWindow()); |
| assertIsBitmapDrawable(m, bitmap); |
| } |
| |
| }; |
| mRule = new TestActivity.TestActivityTestRule(provider1, generateProviderName("activity1")); |
| final TestActivity activity1 = mRule.launchActivity(); |
| final BackgroundManager manager1 = BackgroundManager.getInstance(activity1); |
| |
| TestActivity.Provider provider2 = new TestActivity.Provider() { |
| @Override |
| public void onCreate(TestActivity activity, Bundle savedInstanceState) { |
| super.onCreate(activity, savedInstanceState); |
| BackgroundManager m = BackgroundManager.getInstance(activity); |
| m.attach(activity.getWindow()); |
| assertIsBitmapDrawable(m, bitmap); |
| } |
| }; |
| TestActivity activity2 = launchActivity("activity2", provider2); |
| waitForActivityStop(activity1); |
| final BackgroundManager manager2 = BackgroundManager.getInstance(activity2); |
| |
| final Bitmap bitmap2 = createBitmap(200, 100, Color.GREEN); |
| setBitmapAndVerify(manager2, bitmap2); |
| |
| // after activity2 is launched, activity will keep its drawable because |
| // setAutoReleaseOnStop(false) |
| assertIsBitmapDrawable(manager1, bitmap); |
| |
| activity2.finish(); |
| |
| // when return from the activity, it's still the same bitmap |
| waitForBackgroundAnimationFinish(manager1); |
| assertIsBitmapDrawable(manager1, bitmap); |
| } |
| |
| @Test |
| public void delayDrawableChangeUntilFullAlpha() throws Throwable { |
| final Bitmap bitmap = createBitmap(200, 100, Color.BLUE); |
| TestActivity.Provider provider1 = new TestActivity.Provider() { |
| @Override |
| public void onCreate(TestActivity activity, Bundle savedInstanceState) { |
| super.onCreate(activity, savedInstanceState); |
| BackgroundManager m = BackgroundManager.getInstance(activity); |
| m.setAutoReleaseOnStop(false); |
| m.attach(activity.getWindow()); |
| m.setColor(Color.RED); |
| } |
| |
| }; |
| mRule = new TestActivity.TestActivityTestRule(provider1, generateProviderName("activity1")); |
| final TestActivity activity1 = mRule.launchActivity(); |
| final BackgroundManager manager1 = BackgroundManager.getInstance(activity1); |
| assertIsColorDrawable(manager1, Color.RED); |
| |
| // when set drawable, the change will be pending because alpha is 128 |
| mRule.runOnUiThread(new Runnable() { |
| @Override |
| public void run() { |
| assertSame(manager1.mLayerDrawable, |
| activity1.getWindow().getDecorView().getBackground()); |
| activity1.getWindow().getDecorView().getBackground().setAlpha(128); |
| manager1.setBitmap(bitmap); |
| } |
| }); |
| assertEquals(Color.RED, |
| ((ColorDrawable) manager1.mLayerDrawable.getDrawable(1)).getColor()); |
| |
| // Pending updates executed when set to FULL_ALPHA |
| mRule.runOnUiThread(new Runnable() { |
| @Override |
| public void run() { |
| activity1.getWindow().getDecorView().getBackground().setAlpha( |
| BackgroundManager.FULL_ALPHA); |
| } |
| }); |
| waitForBackgroundAnimationFinish(manager1); |
| assertIsBitmapDrawable(manager1, bitmap); |
| } |
| } |
