/*
* Copyright (C) 2012 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.android.keyguard.test;
import com.android.internal.policy.IKeyguardShowCallback;
import com.android.internal.policy.IKeyguardExitCallback;
import com.android.internal.policy.IKeyguardService;
import android.app.Activity;
import android.app.AlertDialog;
import android.app.admin.DevicePolicyManager;
import android.content.ComponentName;
import android.content.Context;
import android.content.Intent;
import android.content.ServiceConnection;
import android.os.Bundle;
import android.os.Handler;
import android.os.IBinder;
import android.os.RemoteException;
import android.os.SystemClock;
import android.provider.Settings;
import android.util.Log;
import android.view.Menu;
import android.view.MenuInflater;
import android.view.MenuItem;
import android.view.View;
import android.view.View.OnClickListener;
import android.view.WindowManagerPolicy;
import com.android.internal.widget.LockPatternUtils;
import com.android.internal.widget.LockPatternView.Cell;
import java.util.List;
public class KeyguardTestActivity extends Activity implements OnClickListener {
private static final String KEYGUARD_PACKAGE = "com.android.keyguard";
private static final String KEYGUARD_CLASS = "com.android.keyguard.KeyguardService";
private static final String TAG = "LockScreenTestActivity";
private static final int MODE_NONE = 0;
private static final int MODE_PIN = 1;
private static final int MODE_PASSWORD = 2;
private static final int MODE_PATTERN = 3;
private static final int MODE_SIM_PIN = 4;
private static final int MODE_SIM_PUK = 5;
private static final String SECURITY_MODE = "security_mode";
Handler mHandler = new Handler();
IKeyguardService mService = null;
KeyguardShowCallback mKeyguardShowCallback = new KeyguardShowCallback();
KeyguardExitCallback mKeyguardExitCallback = new KeyguardExitCallback();
RemoteServiceConnection mConnection;
private boolean mSentSystemReady;
class KeyguardShowCallback extends IKeyguardShowCallback.Stub {
@Override
public void onShown(IBinder windowToken) throws RemoteException {
Log.v(TAG, "Keyguard is shown, windowToken = " + windowToken);
}
}
class KeyguardExitCallback extends IKeyguardExitCallback.Stub {
@Override
public void onKeyguardExitResult(final boolean success) throws RemoteException {
mHandler.post(new Runnable() {
@Override
public void run() {
new AlertDialog.Builder(KeyguardTestActivity.this)
.setMessage("Result: " + success)
.setPositiveButton("OK", null)
.show();
}
});
}
};
private class RemoteServiceConnection implements ServiceConnection {
public void onServiceConnected(ComponentName className, IBinder service) {
Log.v(TAG, "onServiceConnected()");
mService = IKeyguardService.Stub.asInterface(service);
try {
mService.asBinder().linkToDeath(new IBinder.DeathRecipient() {
@Override
public void binderDied() {
new AlertDialog.Builder(KeyguardTestActivity.this)
.setMessage("Oops! Keygued died")
.setPositiveButton("OK", null)
.show();
}
}, 0);
} catch (RemoteException e) {
Log.w(TAG, "Couldn't linkToDeath");
e.printStackTrace();
}
// try {
// mService.onSystemReady();
// } catch (RemoteException e) {
// Log.v(TAG, "Remote service died trying to call onSystemReady");
// e.printStackTrace();
// }
}
public void onServiceDisconnected(ComponentName className) {
Log.v(TAG, "onServiceDisconnected()");
mService = null;
}
};
private void bindService() {
if (mConnection == null) {
mConnection = new RemoteServiceConnection();
Intent intent = new Intent();
intent.setClassName(KEYGUARD_PACKAGE, KEYGUARD_CLASS);
Log.v(TAG, "BINDING SERVICE: " + KEYGUARD_CLASS);
if (!bindService(intent, mConnection, Context.BIND_AUTO_CREATE)) {
Log.v(TAG, "FAILED TO BIND TO KEYGUARD!");
}
} else {
Log.v(TAG, "Service already bound");
}
}
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.keyguard_test_activity);
final int[] buttons = {
R.id.on_screen_turned_off, R.id.on_screen_turned_on,
R.id.do_keyguard, R.id.verify_unlock
};
for (int i = 0; i < buttons.length; i++) {
findViewById(buttons[i]).setOnClickListener(this);
}
Log.v(TAG, "Binding service...");
bindService();
}
@Override
protected void onSaveInstanceState(Bundle outState) {
super.onSaveInstanceState(outState);
outState.putInt(SECURITY_MODE, mSecurityMode);
}
@Override
protected void onRestoreInstanceState(Bundle savedInstanceState) {
super.onRestoreInstanceState(savedInstanceState);
setMode(savedInstanceState.getInt(SECURITY_MODE));
}
// TODO: Find a secure way to inject mock into keyguard...
// @Override
// public boolean onCreateOptionsMenu(Menu menu) {
// MenuInflater inflater = getMenuInflater();
// inflater.inflate(R.menu.optionmenu, menu);
// return true;
// }
private void setMode(int mode) {
mTestSimPin = false;
mTestSimPuk = false;
mLockPasswordEnabled = false;
mLockPatternEnabled = false;
switch(mode) {
case MODE_NONE:
mSecurityModeMock = DevicePolicyManager.PASSWORD_QUALITY_UNSPECIFIED;
break;
case MODE_PIN:
mSecurityModeMock = DevicePolicyManager.PASSWORD_QUALITY_NUMERIC;
mLockPasswordEnabled = true;
break;
case MODE_PASSWORD:
mSecurityModeMock = DevicePolicyManager.PASSWORD_QUALITY_ALPHABETIC;
mLockPasswordEnabled = true;
break;
case MODE_PATTERN:
mSecurityModeMock = DevicePolicyManager.PASSWORD_QUALITY_SOMETHING;
mLockPatternEnabled = true;
break;
case MODE_SIM_PIN:
mTestSimPin = true;
break;
case MODE_SIM_PUK:
mTestSimPuk = true;
break;
}
mSecurityMode = mode;
}
@Override
public boolean onOptionsItemSelected(MenuItem item) {
// Handle item selection
switch (item.getItemId()) {
case R.id.none_menu_item:
setMode(MODE_NONE);
break;
case R.id.pin_menu_item:
setMode(MODE_PIN);
break;
case R.id.password_menu_item:
setMode(MODE_PASSWORD);
break;
case R.id.pattern_menu_item:
setMode(MODE_PATTERN);
break;
case R.id.sim_pin_menu_item:
setMode(MODE_SIM_PIN);
break;
case R.id.sim_puk_menu_item:
setMode(MODE_SIM_PUK);
break;
case R.id.add_widget_item:
startWidgetPicker();
break;
default:
return super.onOptionsItemSelected(item);
}
try {
mService.doKeyguardTimeout(null);
} catch (RemoteException e) {
Log.e(TAG, "Remote service died");
e.printStackTrace();
}
return true;
}
private void startWidgetPicker() {
startActivity(new Intent(Settings.ACTION_SECURITY_SETTINGS));
}
@Override
public void onClick(View v) {
try {
switch (v.getId()) {
case R.id.on_screen_turned_on:
mService.onScreenTurnedOn(mKeyguardShowCallback);
break;
case R.id.on_screen_turned_off:
mService.onScreenTurnedOff(WindowManagerPolicy.OFF_BECAUSE_OF_USER);
break;
case R.id.do_keyguard:
if (!mSentSystemReady) {
mSentSystemReady = true;
mService.onSystemReady();
}
mService.doKeyguardTimeout(null);
break;
case R.id.verify_unlock:
mService.doKeyguardTimeout(null);
// Wait for keyguard to lock and then try this...
mHandler.postDelayed(new Runnable() {
@Override
public void run() {
try {
mService.verifyUnlock(mKeyguardExitCallback);
} catch (RemoteException e) {
Log.e(TAG, "Failed verifyUnlock()", e);
}
}
}, 5000);
break;
}
} catch (RemoteException e) {
Log.e(TAG, "onClick(): Failed due to remote exeption", e);
}
}
@Override
protected void onPause() {
super.onPause();
try {
if (mService != null) {
mService.setHidden(true);
}
} catch (RemoteException e) {
Log.e(TAG, "Remote service died");
e.printStackTrace();
}
}
protected void onResume() {
super.onResume();
try {
if (mService != null) {
mService.setHidden(false);
}
} catch (RemoteException e) {
Log.e(TAG, "Remote service died");
e.printStackTrace();
}
}
public int mSecurityModeMock;
private boolean mTestSimPin;
private boolean mTestSimPuk;
private boolean mLockPasswordEnabled;
public boolean mLockPatternEnabled;
private int mSecurityMode;
class LockPatternUtilsMock extends LockPatternUtils {
private long mDeadline;
public LockPatternUtilsMock(Context context) {
super(context);
}
@Override
public boolean checkPattern(List<Cell> pattern) {
return pattern.size() > 4;
}
@Override
public boolean checkPassword(String password) {
return password.length() > 4;
}
@Override
public long setLockoutAttemptDeadline() {
final long deadline = SystemClock.elapsedRealtime() + FAILED_ATTEMPT_TIMEOUT_MS;
mDeadline = deadline;
return deadline;
}
@Override
public boolean isLockScreenDisabled() {
return false;
}
@Override
public long getLockoutAttemptDeadline() {
return mDeadline;
}
@Override
public void reportFailedPasswordAttempt() {
// Ignored
}
@Override
public void reportSuccessfulPasswordAttempt() {
// Ignored
}
@Override
public boolean isLockPatternEnabled() {
return mLockPatternEnabled;
}
@Override
public boolean isLockPasswordEnabled() {
return mLockPasswordEnabled;
}
@Override
public int getKeyguardStoredPasswordQuality() {
return mSecurityModeMock;
}
public boolean isSecure() {
return mLockPatternEnabled || mLockPasswordEnabled || mTestSimPin || mTestSimPuk;
}
}
}
|
