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