packages/SystemUI/src/com/android/systemui/doze/DozeDockHandler.java

   1 /*
   2  * Copyright (C) 2018 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.doze;
  18
  19 import android.content.Context;
  20 import android.hardware.display.AmbientDisplayConfiguration;
  21 import android.os.Handler;
  22 import android.os.UserHandle;
  23 import android.util.Log;
  24
  25 import com.android.systemui.dock.DockManager;
  26 import com.android.systemui.doze.DozeMachine.State;
  27
  28 import java.io.PrintWriter;
  29
  30 /**
  31  * Handles dock events for ambient state changes.
  32  */
  33 public class DozeDockHandler implements DozeMachine.Part {
  34
  35     private static final String TAG = "DozeDockHandler";
  36     private static final boolean DEBUG = DozeService.DEBUG;
  37
  38     private final DozeMachine mMachine;
  39     private final DozeHost mDozeHost;
  40     private final AmbientDisplayConfiguration mConfig;
  41     private final Handler mHandler;
  42     private final DockEventListener mDockEventListener = new DockEventListener();
  43     private final DockManager mDockManager;
  44
  45     private int mDockState = DockManager.STATE_NONE;
  46     private boolean mPulsePending;
  47
  48     public DozeDockHandler(Context context, DozeMachine machine, DozeHost dozeHost,
  49             AmbientDisplayConfiguration config, Handler handler, DockManager dockManager) {
  50         mMachine = machine;
  51         mDozeHost = dozeHost;
  52         mConfig = config;
  53         mHandler = handler;
  54         mDockManager = dockManager;
  55     }
  56
  57     @Override
  58     public void transitionTo(DozeMachine.State oldState, DozeMachine.State newState) {
  59         switch (newState) {
  60             case INITIALIZED:
  61                 mDockEventListener.register();
  62                 break;
  63             case DOZE_AOD:
  64                 if (mDockState == DockManager.STATE_DOCKED_HIDE) {
  65                     mMachine.requestState(State.DOZE);
  66                     break;
  67                 }
  68                 // continue below
  69             case DOZE:
  70                 if (mDockState == DockManager.STATE_DOCKED && !mPulsePending) {
  71                     mPulsePending = true;
  72                     mHandler.post(() -> requestPulse(newState));
  73                 }
  74                 break;
  75             case FINISH:
  76                 mDockEventListener.unregister();
  77                 break;
  78             default:
  79                 // no-op
  80         }
  81     }
  82
  83     private void requestPulse(State dozeState) {
  84         if (!mDozeHost.isPulsingBlocked() && dozeState.canPulse()) {
  85             mMachine.requestPulse(DozeLog.PULSE_REASON_DOCKING);
  86         }
  87         mPulsePending = false;
  88     }
  89
  90     private void requestPulseOutNow(State dozeState) {
  91         if (dozeState == State.DOZE_REQUEST_PULSE || dozeState == State.DOZE_PULSING
  92                 || dozeState == State.DOZE_PULSING_BRIGHT) {
  93             final int pulseReason = mMachine.getPulseReason();
  94             if (pulseReason == DozeLog.PULSE_REASON_DOCKING) {
  95                 mDozeHost.stopPulsing();
  96             }
  97         }
  98     }
  99
 100     private boolean isDocked() {
 101         return mDockState == DockManager.STATE_DOCKED
 102                 || mDockState == DockManager.STATE_DOCKED_HIDE;
 103     }
 104
 105     @Override
 106     public void dump(PrintWriter pw) {
 107         pw.print(" DozeDockTriggers docking="); pw.println(isDocked());
 108     }
 109
 110     private class DockEventListener implements DockManager.DockEventListener {
 111         private boolean mRegistered;
 112
 113         @Override
 114         public void onEvent(int event) {
 115             if (DEBUG) Log.d(TAG, "dock event = " + event);
 116             final DozeMachine.State dozeState = mMachine.getState();
 117             mDockState = event;
 118             switch (mDockState) {
 119                 case DockManager.STATE_DOCKED:
 120                     requestPulse(dozeState);
 121                     break;
 122                 case DockManager.STATE_NONE:
 123                     if (dozeState == State.DOZE
 124                             && mConfig.alwaysOnEnabled(UserHandle.USER_CURRENT)) {
 125                         mMachine.requestState(State.DOZE_AOD);
 126                     }
 127                     else {
 128                         requestPulseOutNow(dozeState);
 129                     }
 130                     break;
 131                 case DockManager.STATE_DOCKED_HIDE:
 132                     if (dozeState == State.DOZE_AOD) {
 133                         mMachine.requestState(State.DOZE);
 134                     } else {
 135                         requestPulseOutNow(dozeState);
 136                     }
 137                     break;
 138                 default:
 139                     // no-op
 140             }
 141         }
 142
 143         void register() {
 144             if (mRegistered) {
 145                 return;
 146             }
 147             if (mDockManager != null) {
 148                 mDockManager.addListener(this);
 149             }
 150             mRegistered = true;
 151         }
 152
 153         void unregister() {
 154             if (!mRegistered) {
 155                 return;
 156             }
 157             if (mDockManager != null) {
 158                 mDockManager.removeListener(this);
 159             }
 160             mRegistered = false;
 161         }
 162     }
 163 }