1 /* 2 * Copyright (C) 2010 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 android.app; 18 19 import android.annotation.IntDef; 20 import android.annotation.SystemService; 21 import android.annotation.TestApi; 22 import android.annotation.UnsupportedAppUsage; 23 import android.content.Context; 24 import android.content.res.Configuration; 25 import android.os.RemoteException; 26 import android.os.ServiceManager; 27 import android.os.ServiceManager.ServiceNotFoundException; 28 29 import java.lang.annotation.Retention; 30 import java.lang.annotation.RetentionPolicy; 31 32 /** 33 * This class provides access to the system uimode services. These services 34 * allow applications to control UI modes of the device. 35 * It provides functionality to disable the car mode and it gives access to the 36 * night mode settings. 37 * 38 * <p>These facilities are built on top of the underlying 39 * {@link android.content.Intent#ACTION_DOCK_EVENT} broadcasts that are sent when the user 40 * physical places the device into and out of a dock. When that happens, 41 * the UiModeManager switches the system {@link android.content.res.Configuration} 42 * to the appropriate UI mode, sends broadcasts about the mode switch, and 43 * starts the corresponding mode activity if appropriate. See the 44 * broadcasts {@link #ACTION_ENTER_CAR_MODE} and 45 * {@link #ACTION_ENTER_DESK_MODE} for more information. 46 * 47 * <p>In addition, the user may manually switch the system to car mode without 48 * physically being in a dock. While in car mode -- whether by manual action 49 * from the user or being physically placed in a dock -- a notification is 50 * displayed allowing the user to exit dock mode. Thus the dock mode 51 * represented here may be different than the current state of the underlying 52 * dock event broadcast. 53 */ 54 @SystemService(Context.UI_MODE_SERVICE) 55 public class UiModeManager { 56 private static final String TAG = "UiModeManager"; 57 58 /** 59 * Broadcast sent when the device's UI has switched to car mode, either 60 * by being placed in a car dock or explicit action of the user. After 61 * sending the broadcast, the system will start the intent 62 * {@link android.content.Intent#ACTION_MAIN} with category 63 * {@link android.content.Intent#CATEGORY_CAR_DOCK} 64 * to display the car UI, which typically what an application would 65 * implement to provide their own interface. However, applications can 66 * also monitor this Intent in order to be informed of mode changes or 67 * prevent the normal car UI from being displayed by setting the result 68 * of the broadcast to {@link Activity#RESULT_CANCELED}. 69 */ 70 public static String ACTION_ENTER_CAR_MODE = "android.app.action.ENTER_CAR_MODE"; 71 72 /** 73 * Broadcast sent when the device's UI has switch away from car mode back 74 * to normal mode. Typically used by a car mode app, to dismiss itself 75 * when the user exits car mode. 76 */ 77 public static String ACTION_EXIT_CAR_MODE = "android.app.action.EXIT_CAR_MODE"; 78 79 /** 80 * Broadcast sent when the device's UI has switched to desk mode, 81 * by being placed in a desk dock. After 82 * sending the broadcast, the system will start the intent 83 * {@link android.content.Intent#ACTION_MAIN} with category 84 * {@link android.content.Intent#CATEGORY_DESK_DOCK} 85 * to display the desk UI, which typically what an application would 86 * implement to provide their own interface. However, applications can 87 * also monitor this Intent in order to be informed of mode changes or 88 * prevent the normal desk UI from being displayed by setting the result 89 * of the broadcast to {@link Activity#RESULT_CANCELED}. 90 */ 91 public static String ACTION_ENTER_DESK_MODE = "android.app.action.ENTER_DESK_MODE"; 92 93 /** 94 * Broadcast sent when the device's UI has switched away from desk mode back 95 * to normal mode. Typically used by a desk mode app, to dismiss itself 96 * when the user exits desk mode. 97 */ 98 public static String ACTION_EXIT_DESK_MODE = "android.app.action.EXIT_DESK_MODE"; 99 100 /** @hide */ 101 @IntDef(prefix = { "MODE_" }, value = { 102 MODE_NIGHT_AUTO, 103 MODE_NIGHT_NO, 104 MODE_NIGHT_YES 105 }) 106 @Retention(RetentionPolicy.SOURCE) 107 public @interface NightMode {} 108 109 /** 110 * Constant for {@link #setNightMode(int)} and {@link #getNightMode()}: 111 * automatically switch night mode on and off based on the time. 112 */ 113 public static final int MODE_NIGHT_AUTO = Configuration.UI_MODE_NIGHT_UNDEFINED >> 4; 114 115 /** 116 * Constant for {@link #setNightMode(int)} and {@link #getNightMode()}: 117 * never run in night mode. 118 */ 119 public static final int MODE_NIGHT_NO = Configuration.UI_MODE_NIGHT_NO >> 4; 120 121 /** 122 * Constant for {@link #setNightMode(int)} and {@link #getNightMode()}: 123 * always run in night mode. 124 */ 125 public static final int MODE_NIGHT_YES = Configuration.UI_MODE_NIGHT_YES >> 4; 126 127 private IUiModeManager mService; 128 129 @UnsupportedAppUsage 130 /*package*/ UiModeManager() throws ServiceNotFoundException { 131 mService = IUiModeManager.Stub.asInterface( 132 ServiceManager.getServiceOrThrow(Context.UI_MODE_SERVICE)); 133 } 134 135 /** 136 * Flag for use with {@link #enableCarMode(int)}: go to the car 137 * home activity as part of the enable. Enabling this way ensures 138 * a clean transition between the current activity (in non-car-mode) and 139 * the car home activity that will serve as home while in car mode. This 140 * will switch to the car home activity even if we are already in car mode. 141 */ 142 public static final int ENABLE_CAR_MODE_GO_CAR_HOME = 0x0001; 143 144 /** 145 * Flag for use with {@link #enableCarMode(int)}: allow sleep mode while in car mode. 146 * By default, when this flag is not set, the system may hold a full wake lock to keep the 147 * screen turned on and prevent the system from entering sleep mode while in car mode. 148 * Setting this flag disables such behavior and the system may enter sleep mode 149 * if there is no other user activity and no other wake lock held. 150 * Setting this flag can be relevant for a car dock application that does not require the 151 * screen kept on. 152 */ 153 public static final int ENABLE_CAR_MODE_ALLOW_SLEEP = 0x0002; 154 155 /** 156 * Force device into car mode, like it had been placed in the car dock. 157 * This will cause the device to switch to the car home UI as part of 158 * the mode switch. 159 * @param flags Must be 0. 160 */ 161 public void enableCarMode(int flags) { 162 if (mService != null) { 163 try { 164 mService.enableCarMode(flags); 165 } catch (RemoteException e) { 166 throw e.rethrowFromSystemServer(); 167 } 168 } 169 } 170 171 /** 172 * Flag for use with {@link #disableCarMode(int)}: go to the normal 173 * home activity as part of the disable. Disabling this way ensures 174 * a clean transition between the current activity (in car mode) and 175 * the original home activity (which was typically last running without 176 * being in car mode). 177 */ 178 public static final int DISABLE_CAR_MODE_GO_HOME = 0x0001; 179 180 /** 181 * Turn off special mode if currently in car mode. 182 * @param flags May be 0 or {@link #DISABLE_CAR_MODE_GO_HOME}. 183 */ 184 public void disableCarMode(int flags) { 185 if (mService != null) { 186 try { 187 mService.disableCarMode(flags); 188 } catch (RemoteException e) { 189 throw e.rethrowFromSystemServer(); 190 } 191 } 192 } 193 194 /** 195 * Return the current running mode type. May be one of 196 * {@link Configuration#UI_MODE_TYPE_NORMAL Configuration.UI_MODE_TYPE_NORMAL}, 197 * {@link Configuration#UI_MODE_TYPE_DESK Configuration.UI_MODE_TYPE_DESK}, 198 * {@link Configuration#UI_MODE_TYPE_CAR Configuration.UI_MODE_TYPE_CAR}, 199 * {@link Configuration#UI_MODE_TYPE_TELEVISION Configuration.UI_MODE_TYPE_TELEVISION}, 200 * {@link Configuration#UI_MODE_TYPE_APPLIANCE Configuration.UI_MODE_TYPE_APPLIANCE}, 201 * {@link Configuration#UI_MODE_TYPE_WATCH Configuration.UI_MODE_TYPE_WATCH}, or 202 * {@link Configuration#UI_MODE_TYPE_VR_HEADSET Configuration.UI_MODE_TYPE_VR_HEADSET}. 203 */ 204 public int getCurrentModeType() { 205 if (mService != null) { 206 try { 207 return mService.getCurrentModeType(); 208 } catch (RemoteException e) { 209 throw e.rethrowFromSystemServer(); 210 } 211 } 212 return Configuration.UI_MODE_TYPE_NORMAL; 213 } 214 215 /** 216 * Sets the system-wide night mode. 217 * <p> 218 * The mode can be one of: 219 * <ul> 220 * <li><em>{@link #MODE_NIGHT_NO}<em> sets the device into 221 * {@code notnight} mode</li> 222 * <li><em>{@link #MODE_NIGHT_YES}</em> sets the device into 223 * {@code night} mode</li> 224 * <li><em>{@link #MODE_NIGHT_AUTO}</em> automatically switches between 225 * {@code night} and {@code notnight} based on the device's current 226 * location and certain other sensors</li> 227 * </ul> 228 * <p> 229 * <strong>Note:</strong> On API 22 and below, changes to the night mode 230 * are only effective when the {@link Configuration#UI_MODE_TYPE_CAR car} 231 * or {@link Configuration#UI_MODE_TYPE_DESK desk} mode is enabled on a 232 * device. On API 23 through API 28, changes to night mode are always effective. 233 * <p> 234 * Starting in API 29, when the device is in car mode and this method is called, night mode 235 * will change, but the new setting is not persisted and the previously persisted setting 236 * will be restored when the device exits car mode. 237 * <p> 238 * Changes to night mode take effect globally and will result in a configuration change 239 * (and potentially an Activity lifecycle event) being applied to all running apps. 240 * Developers interested in an app-local implementation of night mode should consider using 241 * {@link android.support.v7.app.AppCompatDelegate#setDefaultNightMode(int)} to manage the 242 * -night qualifier locally. 243 * 244 * @param mode the night mode to set 245 * @see #getNightMode() 246 */ 247 public void setNightMode(@NightMode int mode) { 248 if (mService != null) { 249 try { 250 mService.setNightMode(mode); 251 } catch (RemoteException e) { 252 throw e.rethrowFromSystemServer(); 253 } 254 } 255 } 256 257 /** 258 * Returns the currently configured night mode. 259 * <p> 260 * May be one of: 261 * <ul> 262 * <li>{@link #MODE_NIGHT_NO}</li> 263 * <li>{@link #MODE_NIGHT_YES}</li> 264 * <li>{@link #MODE_NIGHT_AUTO}</li> 265 * <li>{@code -1} on error</li> 266 * </ul> 267 * 268 * @return the current night mode, or {@code -1} on error 269 * @see #setNightMode(int) 270 */ 271 public @NightMode int getNightMode() { 272 if (mService != null) { 273 try { 274 return mService.getNightMode(); 275 } catch (RemoteException e) { 276 throw e.rethrowFromSystemServer(); 277 } 278 } 279 return -1; 280 } 281 282 /** 283 * @return If UI mode is locked or not. When UI mode is locked, calls to change UI mode 284 * like {@link #enableCarMode(int)} will silently fail. 285 * @hide 286 */ 287 @TestApi 288 public boolean isUiModeLocked() { 289 if (mService != null) { 290 try { 291 return mService.isUiModeLocked(); 292 } catch (RemoteException e) { 293 throw e.rethrowFromSystemServer(); 294 } 295 } 296 return true; 297 } 298 299 /** 300 * Returns whether night mode is locked or not. 301 * <p> 302 * When night mode is locked, only privileged system components may change 303 * night mode and calls from non-privileged applications to change night 304 * mode will fail silently. 305 * 306 * @return {@code true} if night mode is locked or {@code false} otherwise 307 * @hide 308 */ 309 @TestApi 310 public boolean isNightModeLocked() { 311 if (mService != null) { 312 try { 313 return mService.isNightModeLocked(); 314 } catch (RemoteException e) { 315 throw e.rethrowFromSystemServer(); 316 } 317 } 318 return true; 319 } 320 } 321
