DozeFactory.java revision 0fb55aedaebd0d060254e9f8fe042fa65ce9b448 
1/*
2 * Copyright (C) 2016 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 com.android.systemui.doze;
18
19import android.app.AlarmManager;
20import android.app.Application;
21import android.app.PendingIntent;
22import android.content.Context;
23import android.hardware.SensorManager;
24import android.os.Handler;
25
26import com.android.internal.hardware.AmbientDisplayConfiguration;
27import com.android.systemui.SystemUIApplication;
28import com.android.systemui.plugins.doze.DozeProvider;
29import com.android.systemui.statusbar.phone.DozeParameters;
30import com.android.systemui.util.wakelock.DelayedWakeLock;
31import com.android.systemui.util.wakelock.WakeLock;
32
33public class DozeFactory {
34
35    private final DozeProvider mDozePlugin;
36
37    public DozeFactory(DozeProvider plugin) {
38        mDozePlugin = plugin;
39    }
40
41    /** Creates a DozeMachine with its parts for {@code dozeService}. */
42    public DozeMachine assembleMachine(DozeService dozeService) {
43        Context context = dozeService;
44        SensorManager sensorManager = context.getSystemService(SensorManager.class);
45        AlarmManager alarmManager = context.getSystemService(AlarmManager.class);
46
47        DozeHost host = getHost(dozeService);
48        AmbientDisplayConfiguration config = new AmbientDisplayConfiguration(context);
49        DozeParameters params = new DozeParameters(context);
50        Handler handler = new Handler();
51        WakeLock wakeLock = new DelayedWakeLock(handler,
52                WakeLock.createPartial(context, "Doze"));
53
54        DozeMachine machine = new DozeMachine(
55                DozeSuspendScreenStatePreventingAdapter.wrapIfNeeded(
56                        DozeScreenStatePreventingAdapter.wrapIfNeeded(dozeService, params), params),
57                config,
58                wakeLock);
59        machine.setParts(new DozeMachine.Part[]{
60                createDozeTriggers(context, sensorManager, host, config, params, handler, wakeLock,
61                        machine),
62                createDozeUi(context, host, wakeLock, machine, handler, alarmManager),
63        });
64
65        return machine;
66    }
67
68    private DozeTriggers createDozeTriggers(Context context, SensorManager sensorManager,
69            DozeHost host, AmbientDisplayConfiguration config, DozeParameters params,
70            Handler handler, WakeLock wakeLock, DozeMachine machine) {
71        boolean allowPulseTriggers = mDozePlugin == null || mDozePlugin.allowDefaultPulseTriggers();
72        return new DozeTriggers(context, machine, host, config, params,
73                sensorManager, handler, wakeLock, allowPulseTriggers);
74    }
75
76    private DozeMachine.Part createDozeUi(Context context, DozeHost host, WakeLock wakeLock,
77            DozeMachine machine, Handler handler, AlarmManager alarmManager) {
78        if (mDozePlugin != null) {
79            DozeProvider.DozeUi dozeUi = mDozePlugin.provideDozeUi(context,
80                    pluginMachine(context, machine, host),
81                    wakeLock);
82            return (oldState, newState) -> {
83                dozeUi.transitionTo(pluginState(oldState),
84                        pluginState(newState));
85            };
86        } else {
87            return new DozeUi(context, alarmManager, machine, wakeLock, host, handler);
88        }
89    }
90
91    private DozeProvider.DozeMachine pluginMachine(Context context, DozeMachine machine,
92            DozeHost host) {
93        return new DozeProvider.DozeMachine() {
94            @Override
95            public void requestState(DozeProvider.DozeState state) {
96                if (state == DozeProvider.DozeState.WAKE_UP) {
97                    machine.wakeUp();
98                    return;
99                }
100                machine.requestState(implState(state));
101            }
102
103            @Override
104            public void requestSendIntent(PendingIntent intent) {
105                host.startPendingIntentDismissingKeyguard(intent);
106            }
107        };
108    }
109
110    private DozeMachine.State implState(DozeProvider.DozeState s) {
111        switch (s) {
112            case UNINITIALIZED:
113                return DozeMachine.State.UNINITIALIZED;
114            case INITIALIZED:
115                return DozeMachine.State.INITIALIZED;
116            case DOZE:
117                return DozeMachine.State.DOZE;
118            case DOZE_AOD:
119                return DozeMachine.State.DOZE_AOD;
120            case DOZE_REQUEST_PULSE:
121                return DozeMachine.State.DOZE_REQUEST_PULSE;
122            case DOZE_PULSING:
123                return DozeMachine.State.DOZE_PULSING;
124            case DOZE_PULSE_DONE:
125                return DozeMachine.State.DOZE_PULSE_DONE;
126            case FINISH:
127                return DozeMachine.State.FINISH;
128            default:
129                throw new IllegalArgumentException("Unknown state: " + s);
130        }
131    }
132
133    private DozeProvider.DozeState pluginState(DozeMachine.State s) {
134        switch (s) {
135            case UNINITIALIZED:
136                return DozeProvider.DozeState.UNINITIALIZED;
137            case INITIALIZED:
138                return DozeProvider.DozeState.INITIALIZED;
139            case DOZE:
140                return DozeProvider.DozeState.DOZE;
141            case DOZE_AOD:
142                return DozeProvider.DozeState.DOZE_AOD;
143            case DOZE_REQUEST_PULSE:
144                return DozeProvider.DozeState.DOZE_REQUEST_PULSE;
145            case DOZE_PULSING:
146                return DozeProvider.DozeState.DOZE_PULSING;
147            case DOZE_PULSE_DONE:
148                return DozeProvider.DozeState.DOZE_PULSE_DONE;
149            case FINISH:
150                return DozeProvider.DozeState.FINISH;
151            default:
152                throw new IllegalArgumentException("Unknown state: " + s);
153        }
154    }
155
156    public static DozeHost getHost(DozeService service) {
157        Application appCandidate = service.getApplication();
158        final SystemUIApplication app = (SystemUIApplication) appCandidate;
159        return app.getComponent(DozeHost.class);
160    }
161}
162