1/* 2 * Copyright (C) 2017 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 */ 16package android.os; 17 18import android.app.ActivityManager; 19import android.app.VrManager; 20import android.content.ComponentName; 21import android.content.Context; 22import android.content.pm.PackageManager; 23import android.os.Process; 24import android.provider.Settings; 25import android.test.ActivityInstrumentationTestCase2; 26import android.test.suitebuilder.annotation.SmallTest; 27import android.util.Log; 28 29/** 30 * Tests ActivityManager#setPersistentVrThread and ActivityManager#setVrThread's 31 * interaction with persistent VR mode. 32 */ 33public class SetPersistentVrThreadTest extends ActivityInstrumentationTestCase2<TestVrActivity> { 34 private TestVrActivity mActivity; 35 private ActivityManager mActivityManager; 36 private VrManager mVrManager; 37 private Context mContext; 38 private String mOldVrListener; 39 private ComponentName mRequestedComponent; 40 private static final int SCHED_OTHER = 0; 41 private static final int SCHED_FIFO = 1; 42 private static final int SCHED_RESET_ON_FORK = 0x40000000; 43 public static final String ENABLED_VR_LISTENERS = "enabled_vr_listeners"; 44 private static final String TAG = "VrSetPersistentFIFOThreadTest"; 45 46 public SetPersistentVrThreadTest() { 47 super(TestVrActivity.class); 48 } 49 50 @Override 51 protected void setUp() throws Exception { 52 super.setUp(); 53 mContext = getInstrumentation().getTargetContext(); 54 mActivityManager = (ActivityManager) mContext.getSystemService(Context.ACTIVITY_SERVICE); 55 mVrManager = (VrManager) mContext.getSystemService(Context.VR_SERVICE); 56 57 mRequestedComponent = new ComponentName(mContext, 58 TestVrActivity.TestVrListenerService.class); 59 mOldVrListener = Settings.Secure.getString(mContext.getContentResolver(), 60 ENABLED_VR_LISTENERS); 61 Settings.Secure.putString(mContext.getContentResolver(), ENABLED_VR_LISTENERS, 62 mRequestedComponent.flattenToString()); 63 mActivity = getActivity(); 64 } 65 66 @Override 67 protected void tearDown() throws Exception { 68 try { 69 setPersistentVrModeEnabled(false); 70 } catch (Throwable e) { 71 // pass 72 } 73 Settings.Secure.putString(mContext.getContentResolver(), ENABLED_VR_LISTENERS, 74 mOldVrListener); 75 super.tearDown(); 76 } 77 78 private void setPersistentVrModeEnabled(boolean enable) throws Throwable { 79 mVrManager.setPersistentVrModeEnabled(enable); 80 // Allow the system time to send out callbacks for persistent VR mode. 81 Thread.sleep(200); 82 } 83 84 @SmallTest 85 public void testSetPersistentVrThreadAPISuccess() throws Throwable { 86 if (!mActivity.getPackageManager().hasSystemFeature( 87 PackageManager.FEATURE_VR_MODE_HIGH_PERFORMANCE)) { 88 return; 89 } 90 91 int vr_thread = 0, policy = 0; 92 vr_thread = Process.myTid(); 93 94 setPersistentVrModeEnabled(true); 95 mActivityManager.setPersistentVrThread(vr_thread); 96 policy = (int) Process.getThreadScheduler(vr_thread); 97 assertEquals((SCHED_FIFO | SCHED_RESET_ON_FORK), policy); 98 99 // Check that the thread loses priority when persistent mode is disabled. 100 setPersistentVrModeEnabled(false); 101 policy = (int) Process.getThreadScheduler(vr_thread); 102 assertEquals(SCHED_OTHER, policy); 103 104 // Check that disabling VR mode when in persistent mode does not affect the persistent 105 // thread. 106 mActivity.setVrModeEnabled(true, mRequestedComponent); 107 Thread.sleep(200); 108 setPersistentVrModeEnabled(true); 109 Thread.sleep(200); 110 mActivityManager.setPersistentVrThread(vr_thread); 111 policy = (int) Process.getThreadScheduler(vr_thread); 112 assertEquals((SCHED_FIFO | SCHED_RESET_ON_FORK), policy); 113 mActivity.setVrModeEnabled(false, mRequestedComponent); 114 Thread.sleep(200); 115 assertEquals((SCHED_FIFO | SCHED_RESET_ON_FORK), policy); 116 setPersistentVrModeEnabled(false); 117 policy = (int) Process.getThreadScheduler(vr_thread); 118 assertEquals(SCHED_OTHER, policy); 119 } 120 121 @SmallTest 122 public void testSetPersistentVrThreadAPIFailure() throws Throwable { 123 if (!mActivity.getPackageManager().hasSystemFeature( 124 PackageManager.FEATURE_VR_MODE_HIGH_PERFORMANCE)) { 125 return; 126 } 127 int vr_thread = 0, policy = 0; 128 vr_thread = Process.myTid(); 129 mActivityManager.setPersistentVrThread(vr_thread); 130 policy = (int) Process.getThreadScheduler(vr_thread); 131 assertEquals(SCHED_OTHER, policy); 132 } 133 134 @SmallTest 135 public void testSetVrThreadAPIFailsInPersistentMode() throws Throwable { 136 if (!mActivity.getPackageManager().hasSystemFeature( 137 PackageManager.FEATURE_VR_MODE_HIGH_PERFORMANCE)) { 138 return; 139 } 140 int vr_thread = 0, policy = 0; 141 mActivity.setVrModeEnabled(true, mRequestedComponent); 142 vr_thread = Process.myTid(); 143 144 setPersistentVrModeEnabled(true); 145 mActivityManager.setVrThread(vr_thread); 146 policy = (int) Process.getThreadScheduler(vr_thread); 147 assertEquals(SCHED_OTHER, policy); 148 setPersistentVrModeEnabled(false); 149 150 // When not in persistent mode the API works again. 151 mActivity.setVrModeEnabled(true, mRequestedComponent); 152 mActivityManager.setVrThread(vr_thread); 153 policy = (int) Process.getThreadScheduler(vr_thread); 154 assertEquals((SCHED_FIFO | SCHED_RESET_ON_FORK), policy); 155 156 // The thread loses priority when persistent mode is disabled. 157 setPersistentVrModeEnabled(true); 158 policy = (int) Process.getThreadScheduler(vr_thread); 159 assertEquals(SCHED_OTHER, policy); 160 setPersistentVrModeEnabled(false); 161 } 162} 163