KeyguardServiceDelegate.java revision 5ecd81154fa039961f65bb4e36d18ac555b0d1d6 
1package com.android.internal.policy.impl.keyguard;
2
3import android.content.ComponentName;
4import android.content.Context;
5import android.content.Intent;
6import android.content.ServiceConnection;
7import android.os.Bundle;
8import android.os.IBinder;
9import android.os.RemoteException;
10import android.os.UserHandle;
11import android.util.Log;
12import android.util.Slog;
13import android.view.WindowManagerPolicy.OnKeyguardExitResult;
14
15import com.android.internal.policy.IKeyguardResult;
16import com.android.internal.policy.IKeyguardService;
17import com.android.internal.widget.LockPatternUtils;
18import com.android.internal.policy.impl.KeyguardServiceWrapper;
19import com.android.internal.policy.impl.keyguard.KeyguardServiceDelegate.ShowListener;
20
21/**
22 * A local class that keeps a cache of keyguard state that can be restored in the event
23 * keyguard crashes. It currently also allows runtime-selectable
24 * local or remote instances of keyguard.
25 */
26public class KeyguardServiceDelegate {
27    private static final String KEYGUARD_PACKAGE = "com.android.keyguard";
28    private static final String KEYGUARD_CLASS = "com.android.keyguard.KeyguardService";
29    private static final String TAG = "KeyguardServiceDelegate";
30    private final static boolean DEBUG = true;
31    private ServiceConnection mKeyguardConnection;
32    protected KeyguardServiceWrapper mKeyguardService;
33    private KeyguardState mKeyguardState = new KeyguardState();
34
35    /* package */ class KeyguardState {
36        boolean showing;
37        boolean showingAndNotHidden;
38        boolean inputRestricted;
39        boolean hidden;
40        boolean secure;
41        boolean dreaming;
42        boolean systemIsReady;
43        public boolean enabled;
44        public boolean dismissable;
45        public int offReason;
46        public int currentUser;
47        public boolean screenIsOn;
48        public boolean restoreStateWhenConnected;
49        public ShowListener showListener;
50    };
51
52    public interface ShowListener {
53        public void onShown(IBinder windowToken);
54    }
55
56    private class KeyguardResult extends IKeyguardResult.Stub {
57        private ShowListener mShowListener;
58        private OnKeyguardExitResult mOnKeyguardExitResult;
59
60        KeyguardResult(ShowListener showListener, OnKeyguardExitResult onKeyguardExitResult) {
61            mShowListener = showListener;
62            mOnKeyguardExitResult = onKeyguardExitResult;
63        }
64
65        @Override
66        public IBinder asBinder() {
67            if (DEBUG) Log.v(TAG, "asBinder() called for KeyguardResult, "
68                    + "mShowListener = " + mShowListener
69                    + ", mOnKeyguardExitResult = " + mOnKeyguardExitResult);
70            return super.asBinder();
71        }
72
73        @Override
74        public void onShown(IBinder windowToken) throws RemoteException {
75            if (DEBUG) Log.v(TAG, "**** SHOWN CALLED ****");
76            if (mShowListener != null) {
77                mShowListener.onShown(windowToken);
78            }
79        }
80
81        @Override
82        public void onKeyguardExitResult(boolean success) throws RemoteException {
83            if (DEBUG) Log.v(TAG, "**** onKeyguardExitResult(" + success +") CALLED ****");
84            if (mOnKeyguardExitResult != null) {
85                mOnKeyguardExitResult.onKeyguardExitResult(success);
86            }
87        }
88    };
89
90    public KeyguardServiceDelegate(Context context, LockPatternUtils lockPatternUtils) {
91        mKeyguardConnection = createServiceConnection();
92        Intent intent = new Intent();
93        intent.setClassName(KEYGUARD_PACKAGE, KEYGUARD_CLASS);
94        if (!context.bindServiceAsUser(intent, mKeyguardConnection,
95                Context.BIND_AUTO_CREATE, UserHandle.OWNER)) {
96            if (DEBUG) Log.v(TAG, "*** Keyguard: can't bind to " + KEYGUARD_CLASS);
97        } else {
98            if (DEBUG) Log.v(TAG, "*** Keyguard started");
99        }
100    }
101
102    private ServiceConnection createServiceConnection() {
103        return new ServiceConnection() {
104
105            @Override
106            public void onServiceConnected(ComponentName name, IBinder service) {
107                if (DEBUG) Log.v(TAG, "*** Keyguard connected (yay!)");
108                mKeyguardService = new KeyguardServiceWrapper(
109                        IKeyguardService.Stub.asInterface(service));
110                if (mKeyguardState.systemIsReady) {
111                    mKeyguardService.onSystemReady();
112                }
113            }
114
115            @Override
116            public void onServiceDisconnected(ComponentName name) {
117                if (DEBUG) Log.v(TAG, "*** Keyguard disconnected (boo!)");
118                mKeyguardService = null;
119            }
120
121        };
122    }
123
124    public boolean isShowing() {
125        if (mKeyguardService != null) {
126            mKeyguardState.showing = mKeyguardService.isShowing();
127        }
128        return mKeyguardState.showing;
129    }
130
131    public boolean isShowingAndNotHidden() {
132        if (mKeyguardService != null) {
133            mKeyguardState.showingAndNotHidden = mKeyguardService.isShowingAndNotHidden();
134        }
135        return mKeyguardState.showingAndNotHidden;
136    }
137
138    public boolean isInputRestricted() {
139        if (mKeyguardService != null) {
140            mKeyguardState.inputRestricted = mKeyguardService.isInputRestricted();
141        }
142        return mKeyguardState.inputRestricted;
143    }
144
145    public void verifyUnlock(final OnKeyguardExitResult onKeyguardExitResult) {
146        if (mKeyguardService != null) {
147            mKeyguardService.verifyUnlock(new KeyguardResult(null, onKeyguardExitResult));
148        }
149    }
150
151    public void keyguardDone(boolean authenticated, boolean wakeup) {
152        if (mKeyguardService != null) {
153            mKeyguardService.keyguardDone(authenticated, wakeup);
154        }
155    }
156
157    public void setHidden(boolean isHidden) {
158        if (mKeyguardService != null) {
159            mKeyguardService.setHidden(isHidden);
160        }
161        mKeyguardState.hidden = isHidden;
162    }
163
164    public void dismiss() {
165        if (mKeyguardService != null) {
166            mKeyguardService.dismiss();
167        }
168    }
169
170    public boolean isSecure() {
171        if (mKeyguardService != null) {
172            mKeyguardState.secure = mKeyguardService.isSecure();
173        }
174        return mKeyguardState.secure;
175    }
176
177    public void onWakeKeyWhenKeyguardShowingTq(int keycodePower) {
178        if (mKeyguardService != null) {
179            mKeyguardService.onWakeKeyWhenKeyguardShowingTq(keycodePower);
180        }
181    }
182
183    public void onWakeMotionWhenKeyguardShowingTq() {
184        if (mKeyguardService != null) {
185            mKeyguardService.onWakeMotionWhenKeyguardShowingTq();
186        }
187    }
188
189    public void onDreamingStarted() {
190        if (mKeyguardService != null) {
191            mKeyguardService.onDreamingStarted();
192        }
193        mKeyguardState.dreaming = true;
194    }
195
196    public void onDreamingStopped() {
197        if (mKeyguardService != null) {
198            mKeyguardService.onDreamingStopped();
199        }
200        mKeyguardState.dreaming = false;
201    }
202
203    public void onScreenTurnedOn(final ShowListener showListener) {
204        if (mKeyguardService != null) {
205            if (DEBUG) Log.v(TAG, "onScreenTurnedOn(showListener = " + showListener + ")");
206            mKeyguardService.onScreenTurnedOn(new KeyguardResult(showListener, null));
207        } else {
208            // try again when we establish a connection
209            if (DEBUG) Log.w(TAG, "onScreenTurnedOn(): no keyguard service!");
210            mKeyguardState.showListener = showListener;
211            mKeyguardState.restoreStateWhenConnected = true;
212        }
213        mKeyguardState.screenIsOn = true;
214    }
215
216    public void onScreenTurnedOff(int why) {
217        if (mKeyguardService != null) {
218            mKeyguardService.onScreenTurnedOff(why);
219        }
220        mKeyguardState.offReason = why;
221        mKeyguardState.screenIsOn = false;
222    }
223
224    public void setKeyguardEnabled(boolean enabled) {
225        if (mKeyguardService != null) {
226            mKeyguardService.setKeyguardEnabled(enabled);
227        }
228        mKeyguardState.enabled = enabled;
229    }
230
231    public boolean isDismissable() {
232        if (mKeyguardService != null) {
233            mKeyguardState.dismissable = mKeyguardService.isDismissable();
234        }
235        return mKeyguardState.dismissable;
236    }
237
238    public void onSystemReady() {
239        if (mKeyguardService != null) {
240            mKeyguardService.onSystemReady();
241        } else {
242            if (DEBUG) Log.v(TAG, "onSystemReady() called before keyguard service was ready");
243            mKeyguardState.systemIsReady = true;
244        }
245    }
246
247    public void doKeyguardTimeout(Bundle options) {
248        if (mKeyguardService != null) {
249            mKeyguardService.doKeyguardTimeout(options);
250        }
251    }
252
253    public void showAssistant() {
254        if (mKeyguardService != null) {
255            mKeyguardService.showAssistant();
256        }
257    }
258
259    public void setCurrentUser(int newUserId) {
260        if (mKeyguardService != null) {
261            mKeyguardService.setCurrentUser(newUserId);
262        }
263        mKeyguardState.currentUser = newUserId;
264    }
265
266    public void userActivity() {
267        if (mKeyguardService != null) {
268            mKeyguardService.userActivity();
269        }
270    }
271
272}
273