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