Home | History | Annotate | Download | only in phone 
      1 /*
      2  * Copyright (C) 2014 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 com.android.systemui.statusbar.phone;
     18 
     19 import android.app.ActivityManagerNative;
     20 import android.app.IActivityManager;
     21 import android.content.Context;
     22 import android.content.pm.ActivityInfo;
     23 import android.content.res.Resources;
     24 import android.graphics.PixelFormat;
     25 import android.os.RemoteException;
     26 import android.os.SystemProperties;
     27 import android.os.Trace;
     28 import android.util.Log;
     29 import android.view.Gravity;
     30 import android.view.View;
     31 import android.view.ViewGroup;
     32 import android.view.WindowManager;
     33 
     34 import com.android.keyguard.R;
     35 import com.android.systemui.keyguard.KeyguardViewMediator;
     36 import com.android.systemui.statusbar.BaseStatusBar;
     37 import com.android.systemui.statusbar.RemoteInputController;
     38 import com.android.systemui.statusbar.StatusBarState;
     39 
     40 import java.io.FileDescriptor;
     41 import java.io.PrintWriter;
     42 import java.lang.reflect.Field;
     43 
     44 /**
     45  * Encapsulates all logic for the status bar window state management.
     46  */
     47 public class StatusBarWindowManager implements RemoteInputController.Callback {
     48 
     49     private static final String TAG = "StatusBarWindowManager";
     50 
     51     private final Context mContext;
     52     private final WindowManager mWindowManager;
     53     private final IActivityManager mActivityManager;
     54     private View mStatusBarView;
     55     private WindowManager.LayoutParams mLp;
     56     private WindowManager.LayoutParams mLpChanged;
     57     private boolean mHasTopUi;
     58     private boolean mHasTopUiChanged;
     59     private int mBarHeight;
     60     private final boolean mKeyguardScreenRotation;
     61     private final float mScreenBrightnessDoze;
     62     private final State mCurrentState = new State();
     63 
     64     public StatusBarWindowManager(Context context) {
     65         mContext = context;
     66         mWindowManager = (WindowManager) context.getSystemService(Context.WINDOW_SERVICE);
     67         mActivityManager = ActivityManagerNative.getDefault();
     68         mKeyguardScreenRotation = shouldEnableKeyguardScreenRotation();
     69         mScreenBrightnessDoze = mContext.getResources().getInteger(
     70                 com.android.internal.R.integer.config_screenBrightnessDoze) / 255f;
     71     }
     72 
     73     private boolean shouldEnableKeyguardScreenRotation() {
     74         Resources res = mContext.getResources();
     75         return SystemProperties.getBoolean("lockscreen.rot_override", false)
     76                 || res.getBoolean(R.bool.config_enableLockScreenRotation);
     77     }
     78 
     79     /**
     80      * Adds the status bar view to the window manager.
     81      *
     82      * @param statusBarView The view to add.
     83      * @param barHeight The height of the status bar in collapsed state.
     84      */
     85     public void add(View statusBarView, int barHeight) {
     86 
     87         // Now that the status bar window encompasses the sliding panel and its
     88         // translucent backdrop, the entire thing is made TRANSLUCENT and is
     89         // hardware-accelerated.
     90         mLp = new WindowManager.LayoutParams(
     91                 ViewGroup.LayoutParams.MATCH_PARENT,
     92                 barHeight,
     93                 WindowManager.LayoutParams.TYPE_STATUS_BAR,
     94                 WindowManager.LayoutParams.FLAG_NOT_FOCUSABLE
     95                         | WindowManager.LayoutParams.FLAG_TOUCHABLE_WHEN_WAKING
     96                         | WindowManager.LayoutParams.FLAG_SPLIT_TOUCH
     97                         | WindowManager.LayoutParams.FLAG_WATCH_OUTSIDE_TOUCH
     98                         | WindowManager.LayoutParams.FLAG_DRAWS_SYSTEM_BAR_BACKGROUNDS,
     99                 PixelFormat.TRANSLUCENT);
    100         mLp.flags |= WindowManager.LayoutParams.FLAG_HARDWARE_ACCELERATED;
    101         mLp.gravity = Gravity.TOP;
    102         mLp.softInputMode = WindowManager.LayoutParams.SOFT_INPUT_ADJUST_RESIZE;
    103         mLp.setTitle("StatusBar");
    104         mLp.packageName = mContext.getPackageName();
    105         mStatusBarView = statusBarView;
    106         mBarHeight = barHeight;
    107         mWindowManager.addView(mStatusBarView, mLp);
    108         mLpChanged = new WindowManager.LayoutParams();
    109         mLpChanged.copyFrom(mLp);
    110     }
    111 
    112     private void applyKeyguardFlags(State state) {
    113         if (state.keyguardShowing) {
    114             mLpChanged.privateFlags |= WindowManager.LayoutParams.PRIVATE_FLAG_KEYGUARD;
    115         } else {
    116             mLpChanged.privateFlags &= ~WindowManager.LayoutParams.PRIVATE_FLAG_KEYGUARD;
    117         }
    118 
    119         if (state.keyguardShowing && !state.backdropShowing) {
    120             mLpChanged.flags |= WindowManager.LayoutParams.FLAG_SHOW_WALLPAPER;
    121         } else {
    122             mLpChanged.flags &= ~WindowManager.LayoutParams.FLAG_SHOW_WALLPAPER;
    123         }
    124     }
    125 
    126     private void adjustScreenOrientation(State state) {
    127         if (state.isKeyguardShowingAndNotOccluded()) {
    128             if (mKeyguardScreenRotation) {
    129                 mLpChanged.screenOrientation = ActivityInfo.SCREEN_ORIENTATION_USER;
    130             } else {
    131                 mLpChanged.screenOrientation = ActivityInfo.SCREEN_ORIENTATION_NOSENSOR;
    132             }
    133         } else {
    134             mLpChanged.screenOrientation = ActivityInfo.SCREEN_ORIENTATION_UNSPECIFIED;
    135         }
    136     }
    137 
    138     private void applyFocusableFlag(State state) {
    139         boolean panelFocusable = state.statusBarFocusable && state.panelExpanded;
    140         if (state.keyguardShowing && state.keyguardNeedsInput && state.bouncerShowing
    141                 || BaseStatusBar.ENABLE_REMOTE_INPUT && state.remoteInputActive) {
    142             mLpChanged.flags &= ~WindowManager.LayoutParams.FLAG_NOT_FOCUSABLE;
    143             mLpChanged.flags &= ~WindowManager.LayoutParams.FLAG_ALT_FOCUSABLE_IM;
    144         } else if (state.isKeyguardShowingAndNotOccluded() || panelFocusable) {
    145             mLpChanged.flags &= ~WindowManager.LayoutParams.FLAG_NOT_FOCUSABLE;
    146             mLpChanged.flags |= WindowManager.LayoutParams.FLAG_ALT_FOCUSABLE_IM;
    147         } else {
    148             mLpChanged.flags |= WindowManager.LayoutParams.FLAG_NOT_FOCUSABLE;
    149             mLpChanged.flags &= ~WindowManager.LayoutParams.FLAG_ALT_FOCUSABLE_IM;
    150         }
    151 
    152         mLpChanged.softInputMode = WindowManager.LayoutParams.SOFT_INPUT_ADJUST_RESIZE;
    153     }
    154 
    155     private void applyHeight(State state) {
    156         boolean expanded = isExpanded(state);
    157         if (expanded) {
    158             mLpChanged.height = ViewGroup.LayoutParams.MATCH_PARENT;
    159         } else {
    160             mLpChanged.height = mBarHeight;
    161         }
    162     }
    163 
    164     private boolean isExpanded(State state) {
    165         return !state.forceCollapsed && (state.isKeyguardShowingAndNotOccluded()
    166                 || state.panelVisible || state.keyguardFadingAway || state.bouncerShowing
    167                 || state.headsUpShowing);
    168     }
    169 
    170     private void applyFitsSystemWindows(State state) {
    171         boolean fitsSystemWindows = !state.isKeyguardShowingAndNotOccluded();
    172         if (mStatusBarView.getFitsSystemWindows() != fitsSystemWindows) {
    173             mStatusBarView.setFitsSystemWindows(fitsSystemWindows);
    174             mStatusBarView.requestApplyInsets();
    175         }
    176     }
    177 
    178     private void applyUserActivityTimeout(State state) {
    179         if (state.isKeyguardShowingAndNotOccluded()
    180                 && state.statusBarState == StatusBarState.KEYGUARD
    181                 && !state.qsExpanded) {
    182             mLpChanged.userActivityTimeout = KeyguardViewMediator.AWAKE_INTERVAL_DEFAULT_MS;
    183         } else {
    184             mLpChanged.userActivityTimeout = -1;
    185         }
    186     }
    187 
    188     private void applyInputFeatures(State state) {
    189         if (state.isKeyguardShowingAndNotOccluded()
    190                 && state.statusBarState == StatusBarState.KEYGUARD
    191                 && !state.qsExpanded && !state.forceUserActivity) {
    192             mLpChanged.inputFeatures |=
    193                     WindowManager.LayoutParams.INPUT_FEATURE_DISABLE_USER_ACTIVITY;
    194         } else {
    195             mLpChanged.inputFeatures &=
    196                     ~WindowManager.LayoutParams.INPUT_FEATURE_DISABLE_USER_ACTIVITY;
    197         }
    198     }
    199 
    200     private void apply(State state) {
    201         applyKeyguardFlags(state);
    202         applyForceStatusBarVisibleFlag(state);
    203         applyFocusableFlag(state);
    204         adjustScreenOrientation(state);
    205         applyHeight(state);
    206         applyUserActivityTimeout(state);
    207         applyInputFeatures(state);
    208         applyFitsSystemWindows(state);
    209         applyModalFlag(state);
    210         applyBrightness(state);
    211         applyHasTopUi(state);
    212         if (mLp.copyFrom(mLpChanged) != 0) {
    213             mWindowManager.updateViewLayout(mStatusBarView, mLp);
    214         }
    215         if (mHasTopUi != mHasTopUiChanged) {
    216             try {
    217                 mActivityManager.setHasTopUi(mHasTopUiChanged);
    218             } catch (RemoteException e) {
    219                 Log.e(TAG, "Failed to call setHasTopUi", e);
    220             }
    221             mHasTopUi = mHasTopUiChanged;
    222         }
    223     }
    224 
    225     private void applyForceStatusBarVisibleFlag(State state) {
    226         if (state.forceStatusBarVisible) {
    227             mLpChanged.privateFlags |= WindowManager
    228                     .LayoutParams.PRIVATE_FLAG_FORCE_STATUS_BAR_VISIBLE_TRANSPARENT;
    229         } else {
    230             mLpChanged.privateFlags &= ~WindowManager
    231                     .LayoutParams.PRIVATE_FLAG_FORCE_STATUS_BAR_VISIBLE_TRANSPARENT;
    232         }
    233     }
    234 
    235     private void applyModalFlag(State state) {
    236         if (state.headsUpShowing) {
    237             mLpChanged.flags |= WindowManager.LayoutParams.FLAG_NOT_TOUCH_MODAL;
    238         } else {
    239             mLpChanged.flags &= ~WindowManager.LayoutParams.FLAG_NOT_TOUCH_MODAL;
    240         }
    241     }
    242 
    243     private void applyBrightness(State state) {
    244         if (state.forceDozeBrightness) {
    245             mLpChanged.screenBrightness = mScreenBrightnessDoze;
    246         } else {
    247             mLpChanged.screenBrightness = WindowManager.LayoutParams.BRIGHTNESS_OVERRIDE_NONE;
    248         }
    249     }
    250 
    251     private void applyHasTopUi(State state) {
    252         mHasTopUiChanged = isExpanded(state);
    253     }
    254 
    255     public void setKeyguardShowing(boolean showing) {
    256         mCurrentState.keyguardShowing = showing;
    257         apply(mCurrentState);
    258     }
    259 
    260     public void setKeyguardOccluded(boolean occluded) {
    261         mCurrentState.keyguardOccluded = occluded;
    262         apply(mCurrentState);
    263     }
    264 
    265     public void setKeyguardNeedsInput(boolean needsInput) {
    266         mCurrentState.keyguardNeedsInput = needsInput;
    267         apply(mCurrentState);
    268     }
    269 
    270     public void setPanelVisible(boolean visible) {
    271         mCurrentState.panelVisible = visible;
    272         mCurrentState.statusBarFocusable = visible;
    273         apply(mCurrentState);
    274     }
    275 
    276     public void setStatusBarFocusable(boolean focusable) {
    277         mCurrentState.statusBarFocusable = focusable;
    278         apply(mCurrentState);
    279     }
    280 
    281     public void setBouncerShowing(boolean showing) {
    282         mCurrentState.bouncerShowing = showing;
    283         apply(mCurrentState);
    284     }
    285 
    286     public void setBackdropShowing(boolean showing) {
    287         mCurrentState.backdropShowing = showing;
    288         apply(mCurrentState);
    289     }
    290 
    291     public void setKeyguardFadingAway(boolean keyguardFadingAway) {
    292         mCurrentState.keyguardFadingAway = keyguardFadingAway;
    293         apply(mCurrentState);
    294     }
    295 
    296     public void setQsExpanded(boolean expanded) {
    297         mCurrentState.qsExpanded = expanded;
    298         apply(mCurrentState);
    299     }
    300 
    301     public void setForceUserActivity(boolean forceUserActivity) {
    302         mCurrentState.forceUserActivity = forceUserActivity;
    303         apply(mCurrentState);
    304     }
    305 
    306     public void setHeadsUpShowing(boolean showing) {
    307         mCurrentState.headsUpShowing = showing;
    308         apply(mCurrentState);
    309     }
    310 
    311     /**
    312      * @param state The {@link StatusBarState} of the status bar.
    313      */
    314     public void setStatusBarState(int state) {
    315         mCurrentState.statusBarState = state;
    316         apply(mCurrentState);
    317     }
    318 
    319     public void setForceStatusBarVisible(boolean forceStatusBarVisible) {
    320         mCurrentState.forceStatusBarVisible = forceStatusBarVisible;
    321         apply(mCurrentState);
    322     }
    323 
    324     /**
    325      * Force the window to be collapsed, even if it should theoretically be expanded.
    326      * Used for when a heads-up comes in but we still need to wait for the touchable regions to
    327      * be computed.
    328      */
    329     public void setForceWindowCollapsed(boolean force) {
    330         mCurrentState.forceCollapsed = force;
    331         apply(mCurrentState);
    332     }
    333 
    334     public void setPanelExpanded(boolean isExpanded) {
    335         mCurrentState.panelExpanded = isExpanded;
    336         apply(mCurrentState);
    337     }
    338 
    339     @Override
    340     public void onRemoteInputActive(boolean remoteInputActive) {
    341         mCurrentState.remoteInputActive = remoteInputActive;
    342         apply(mCurrentState);
    343     }
    344 
    345     /**
    346      * Set whether the screen brightness is forced to the value we use for doze mode by the status
    347      * bar window.
    348      */
    349     public void setForceDozeBrightness(boolean forceDozeBrightness) {
    350         mCurrentState.forceDozeBrightness = forceDozeBrightness;
    351         apply(mCurrentState);
    352     }
    353 
    354     public void setBarHeight(int barHeight) {
    355         mBarHeight = barHeight;
    356         apply(mCurrentState);
    357     }
    358 
    359     public void dump(FileDescriptor fd, PrintWriter pw, String[] args) {
    360         pw.println("StatusBarWindowManager state:");
    361         pw.println(mCurrentState);
    362     }
    363 
    364     public boolean isShowingWallpaper() {
    365         return !mCurrentState.backdropShowing;
    366     }
    367 
    368     private static class State {
    369         boolean keyguardShowing;
    370         boolean keyguardOccluded;
    371         boolean keyguardNeedsInput;
    372         boolean panelVisible;
    373         boolean panelExpanded;
    374         boolean statusBarFocusable;
    375         boolean bouncerShowing;
    376         boolean keyguardFadingAway;
    377         boolean qsExpanded;
    378         boolean headsUpShowing;
    379         boolean forceStatusBarVisible;
    380         boolean forceCollapsed;
    381         boolean forceDozeBrightness;
    382         boolean forceUserActivity;
    383         boolean backdropShowing;
    384 
    385         /**
    386          * The {@link BaseStatusBar} state from the status bar.
    387          */
    388         int statusBarState;
    389 
    390         boolean remoteInputActive;
    391 
    392         private boolean isKeyguardShowingAndNotOccluded() {
    393             return keyguardShowing && !keyguardOccluded;
    394         }
    395 
    396         @Override
    397         public String toString() {
    398             StringBuilder result = new StringBuilder();
    399             String newLine = "\n";
    400             result.append("Window State {");
    401             result.append(newLine);
    402 
    403             Field[] fields = this.getClass().getDeclaredFields();
    404 
    405             // Print field names paired with their values
    406             for (Field field : fields) {
    407                 result.append("  ");
    408                 try {
    409                     result.append(field.getName());
    410                     result.append(": ");
    411                     //requires access to private field:
    412                     result.append(field.get(this));
    413                 } catch (IllegalAccessException ex) {
    414                 }
    415                 result.append(newLine);
    416             }
    417             result.append("}");
    418 
    419             return result.toString();
    420         }
    421     }
    422 }
    423