android　模拟滑动事件

android　模拟滑动事件，见下面isSlideUnlockScreen()代部分．

package com.android.internal.policy.impl.keyguard;

import android.app.Activity;
import android.content.Context;
import android.graphics.Canvas;
import android.graphics.ColorFilter;
import android.graphics.PixelFormat;
import android.graphics.PorterDuff;
import android.graphics.drawable.Drawable;
import android.media.AudioManager;
import android.media.IAudioService;
import android.os.RemoteException;
import android.os.ServiceManager;
import android.telephony.TelephonyManager;
import android.util.AttributeSet;
import android.util.Log;
import android.util.Slog;
import android.view.KeyEvent;
import android.widget.FrameLayout;

//kaka
import android.view.MotionEvent;
import android.os.SystemClock;

import android.hardware.input.InputManager;
import android.view.InputEvent;

import android.os.Handler;
import android.os.Message;
import android.view.KeyCharacterMap;
import android.os.Binder;
import android.view.InputDevice;

//kaka

import android.provider.Settings;//kaka

/**
* Base class for keyguard view. {@link #reset} is where you should
* reset the state of your view. Use the {@link KeyguardViewCallback} via
* {@link #getCallback()} to send information back (such as poking the wake lock,
* or finishing the keyguard).
*
* Handles intercepting of media keys that still work when the keyguard is
* showing.
*/
public abstract class KeyguardViewBase extends FrameLayout {

private static final int BACKGROUND_COLOR/* = 0x70000000*/;//kaka
private AudioManager mAudioManager;
private TelephonyManager mTelephonyManager = null;
protected KeyguardViewMediator.ViewMediatorCallback mViewMediatorCallback;

//kaka
private static final String KEY_LOCKSCREEN_PAPER = "choose_lock_paper";
private static final String RESOURCE_PKG = "com.android.launcher";
private static final String RESOURCE_TYPE = "drawable";

static{
if("Q".equals(android.util.QpFeatures.QP_PROJ_NAME)){
BACKGROUND_COLOR = 0x0;
}else if("QQ".equals(android.util.QpFeatures.QP_PROJ_NAME)){
BACKGROUND_COLOR = 0x00000000;
}else{
BACKGROUND_COLOR = 0x70000000;
}
}
//kaka

// Whether the volume keys should be handled by keyguard. If true, then
// they will be handled here for specific media types such as music, otherwise
// the audio service will bring up the volume dialog.
private static final boolean KEYGUARD_MANAGES_VOLUME = true;

// This is a faster way to draw the background on devices without hardware acceleration
/// M: Do not make it static, or memory leak may happen
private static final Drawable mBackgroundDrawable = new Drawable() {
@Override
public void draw(Canvas canvas) {
canvas.drawColor(BACKGROUND_COLOR, PorterDuff.Mode.SRC);
}

@Override
public void setAlpha(int alpha) {
}

@Override
public void setColorFilter(ColorFilter cf) {
}

@Override
public int getOpacity() {
return PixelFormat.TRANSLUCENT;
}
};

public KeyguardViewBase(Context context) {
this(context, null);
}

public KeyguardViewBase(Context context, AttributeSet attrs) {
super(context, attrs);
resetBackground();
}

public void resetBackground() {
//kaka
try {
String str = Settings.System.getString(getContext().getContentResolver(), KEY_LOCKSCREEN_PAPER);
if(str == null){
str = "default_lockscreen_wallpaper";
}
Context remContext = mContext.createPackageContext(RESOURCE_PKG, Context.CONTEXT_IGNORE_SECURITY);
if(remContext.getResources().getBoolean(
remContext.getResources().getIdentifier("config_enable_lockscreen_wallpaper", "bool", RESOURCE_PKG))){
final int id = remContext.getResources().getIdentifier(str, RESOURCE_TYPE, RESOURCE_PKG);
Drawable drawable = remContext.getResources().getDrawable(id);
setBackground(drawable);
}else{
setBackground(mBackgroundDrawable);
}
} catch (Exception e) {
}
//kaka
}

/**
* Called when you need to reset the state of your view.
*/
abstract public void reset();

/**
* Called when the screen turned off.
*/
abstract public void onScreenTurnedOff();

/**
* Called when the screen turned on.
*/
abstract public void onScreenTurnedOn();

/**
* Called when the view needs to be shown.
*/
abstract public void show();

/**
* Called when a key has woken the device to give us a chance to adjust our
* state according the the key. We are responsible for waking the device
* (by poking the wake lock) once we are ready.
*
* The 'Tq' suffix is per the documentation in {@link android.view.WindowManagerPolicy}.
* Be sure not to take any action that takes a long time; any significant
* action should be posted to a handler.
*
* @param keyCode The wake key, which may be relevant for configuring the
* keyguard. May be {@link KeyEvent#KEYCODE_UNKNOWN} if waking for a reason
* other than a key press.
*/
abstract public void wakeWhenReadyTq(int keyCode);

/**
* Verify that the user can get past the keyguard securely. This is called,
* for example, when the phone disables the keyguard but then wants to launch
* something else that requires secure access.
*
* The result will be propogated back via {@link KeyguardViewCallback#keyguardDone(boolean)}
*/
abstract public void verifyUnlock();

/**
* Called before this view is being removed.
*/
abstract public void cleanUp();

/**
* Gets the desired user activity timeout in milliseconds, or -1 if the
* default should be used.
*/
abstract public long getUserActivityTimeout();

//kaka
private static final int mEmulateSendMessageDelay = 100;

abstract public boolean isSlideUnlockScreen();

private final static int MONITIOR_MOTION_DOWN = 1;
private final static int MONITIOR_MOTION_MOVE_STEP_1 = 2;
private final static int MONITIOR_MOTION_MOVE_STEP_2 = 3;
private final static int MONITIOR_MOTION_UP = 4;
private final static int MONITIOR_MOTION_DUMMY = 5;

private Handler mHandler = new Handler() {
@Override
public void handleMessage(Message msg) {
if(true){
if (msg.what == MONITIOR_MOTION_DOWN) {
new Thread() {
public void run() {
try {
final long now = SystemClock.uptimeMillis();
android.util.Log.e("kakaka","postDelayed--run--1---------- now="+now);
InputEvent event = (InputEvent)(MotionEvent.obtain(now,now, MotionEvent.ACTION_DOWN, 260.0f, 760.0f, 0));
event.setSource(InputDevice.SOURCE_TOUCHSCREEN);

boolean result = InputManager.getInstance().injectInputEvent(event, 0);
android.util.Log.e("kakaka","postDelayed--run--1---------- tatoal time="+(SystemClock.uptimeMillis()-now)+" result="+result);
} catch (SecurityException e) {
} catch (Exception e) {
}
};
}.start();
}else if (msg.what == MONITIOR_MOTION_MOVE_STEP_1){
new Thread() {
public void run() {
try {
final long now = SystemClock.uptimeMillis();
android.util.Log.e("kakaka","postDelayed--run--2-----------now="+now);
InputEvent event = (InputEvent)(MotionEvent.obtain(now, now, MotionEvent.ACTION_MOVE, 350.0f, 760.0f, 0));
event.setSource(InputDevice.SOURCE_TOUCHSCREEN);

boolean result = InputManager.getInstance().injectInputEvent(event, 0);
android.util.Log.e("kakaka","postDelayed--run--2---------- tatoal time="+(SystemClock.uptimeMillis()-now)+" result="+result);
} catch (SecurityException e) {
} catch (Exception e) {
}
};
}.start();
}else if (msg.what == MONITIOR_MOTION_MOVE_STEP_2){
new Thread() {
public void run() {
try {
final long now = SystemClock.uptimeMillis();
android.util.Log.e("kakaka","postDelayed--run--3------ now="+now);
InputEvent event = (InputEvent)(MotionEvent.obtain(now, now, MotionEvent.ACTION_MOVE, 460.0f, 760.0f, 0));
event.setSource(InputDevice.SOURCE_TOUCHSCREEN);

boolean result = InputManager.getInstance().injectInputEvent(event, 0);
android.util.Log.e("kakaka","postDelayed--run--3---------- tatoal time="+(SystemClock.uptimeMillis()-now)+" result="+result);
} catch (SecurityException e) {
} catch (Exception e) {
}
};
}.start();
}else if (msg.what == MONITIOR_MOTION_UP){
new Thread() {
public void run() {
try {
final long now = SystemClock.uptimeMillis();
android.util.Log.e("kakaka","postDelayed--run--4--------- now="+now);
InputEvent event = (InputEvent)(MotionEvent.obtain(now, now, MotionEvent.ACTION_UP, 460.0f, 760.0f, 0));
event.setSource(InputDevice.SOURCE_TOUCHSCREEN);

boolean result = InputManager.getInstance().injectInputEvent(event, 0);
android.util.Log.e("kakaka","postDelayed--run--4---------- tatoal time="+(SystemClock.uptimeMillis()-now)+" result="+result);
} catch (SecurityException e) {
} catch (Exception e) {
}
};
}.start();
}else if (msg.what == MONITIOR_MOTION_DUMMY){
final long now = SystemClock.uptimeMillis();
android.util.Log.e("kakaka","postDelayed--run--5----------- now="+now);
}
}
}
};
//kaka

@Override
public boolean dispatchKeyEvent(KeyEvent event) {
if (interceptMediaKey(event)) {
return true;
}
return super.dispatchKeyEvent(event);
}

/**
* Allows the media keys to work when the keyguard is showing.
* The media keys should be of no interest to the actual keyguard view(s),
* so intercepting them here should not be of any harm.
* @param event The key event
* @return whether the event was consumed as a media key.
*/
private boolean interceptMediaKey(KeyEvent event) {
final int keyCode = event.getKeyCode();
if (event.getAction() == KeyEvent.ACTION_DOWN) {
switch (keyCode) {
case KeyEvent.KEYCODE_MEDIA_PLAY:
case KeyEvent.KEYCODE_MEDIA_PAUSE:
case KeyEvent.KEYCODE_MEDIA_PLAY_PAUSE:
/* Suppress PLAY/PAUSE toggle when phone is ringing or
* in-call to avoid music playback */
if (mTelephonyManager == null) {
mTelephonyManager = (TelephonyManager) getContext().getSystemService(
Context.TELEPHONY_SERVICE);
}
if (mTelephonyManager != null &&
mTelephonyManager.getCallState() != TelephonyManager.CALL_STATE_IDLE) {
return true; // suppress key event
}
case KeyEvent.KEYCODE_MUTE:
case KeyEvent.KEYCODE_HEADSETHOOK:
case KeyEvent.KEYCODE_MEDIA_STOP:
case KeyEvent.KEYCODE_MEDIA_NEXT:
case KeyEvent.KEYCODE_MEDIA_PREVIOUS:
case KeyEvent.KEYCODE_MEDIA_REWIND:
case KeyEvent.KEYCODE_MEDIA_RECORD:
case KeyEvent.KEYCODE_MEDIA_FAST_FORWARD: {
handleMediaKeyEvent(event);
return true;
}

case KeyEvent.KEYCODE_VOLUME_UP:
case KeyEvent.KEYCODE_VOLUME_DOWN:
case KeyEvent.KEYCODE_VOLUME_MUTE: {
if (KEYGUARD_MANAGES_VOLUME) {
synchronized (this) {
if (mAudioManager == null) {
mAudioManager = (AudioManager) getContext().getSystemService(
Context.AUDIO_SERVICE);
}
}
// Volume buttons should only function for music (local or remote).
// TODO: Actually handle MUTE.
/// M: Handle Music and FM radio two cases @{
int direction = (keyCode == KeyEvent.KEYCODE_VOLUME_UP
? AudioManager.ADJUST_RAISE
: AudioManager.ADJUST_LOWER);
if (mAudioManager.isMusicActive()) {
// TODO: Actually handle MUTE.
mAudioManager.adjustLocalOrRemoteStreamVolume(
AudioManager.STREAM_MUSIC, direction);
} else if (mAudioManager.isFmActive()) {
mAudioManager.adjustLocalOrRemoteStreamVolume(
AudioManager.STREAM_FM, direction);
}
/// @}
// Don't execute default volume behavior
return true;
} else {
return false;
}
}
}
} else if (event.getAction() == KeyEvent.ACTION_UP) {
switch (keyCode) {
case KeyEvent.KEYCODE_MUTE:
case KeyEvent.KEYCODE_HEADSETHOOK:
case KeyEvent.KEYCODE_MEDIA_PLAY:
case KeyEvent.KEYCODE_MEDIA_PAUSE:
case KeyEvent.KEYCODE_MEDIA_PLAY_PAUSE:
case KeyEvent.KEYCODE_MEDIA_STOP:
case KeyEvent.KEYCODE_MEDIA_NEXT:
case KeyEvent.KEYCODE_MEDIA_PREVIOUS:
case KeyEvent.KEYCODE_MEDIA_REWIND:
case KeyEvent.KEYCODE_MEDIA_RECORD:
case KeyEvent.KEYCODE_MEDIA_FAST_FORWARD: {
handleMediaKeyEvent(event);
return true;
}

//kaka
case KeyEvent.KEYCODE_SINGLTAP:{
if(isSlideUnlockScreen() && mHandler!=null&&!mHandler.hasMessages(MONITIOR_MOTION_DUMMY)){
mHandler.sendEmptyMessageDelayed(MONITIOR_MOTION_DOWN,0);
mHandler.sendEmptyMessageDelayed(MONITIOR_MOTION_MOVE_STEP_1,mEmulateSendMessageDelay*1);
mHandler.sendEmptyMessageDelayed(MONITIOR_MOTION_MOVE_STEP_2,mEmulateSendMessageDelay*2);
mHandler.sendEmptyMessageDelayed(MONITIOR_MOTION_UP,mEmulateSendMessageDelay*3);
mHandler.sendEmptyMessageDelayed(MONITIOR_MOTION_DUMMY,6000);
}
return true;
}
//kaka
}
}
return false;
}

void handleMediaKeyEvent(KeyEvent keyEvent) {
IAudioService audioService = IAudioService.Stub.asInterface(
ServiceManager.checkService(Context.AUDIO_SERVICE));
if (audioService != null) {
try {
audioService.dispatchMediaKeyEvent(keyEvent);
} catch (RemoteException e) {
Log.e("KeyguardViewBase", "dispatchMediaKeyEvent threw exception " + e);
}
} else {
Slog.w("KeyguardViewBase", "Unable to find IAudioService for media key event");
}
}

@Override
public void dispatchSystemUiVisibilityChanged(int visibility) {
super.dispatchSystemUiVisibilityChanged(visibility);

if (!(mContext instanceof Activity)) {
setSystemUiVisibility(STATUS_BAR_DISABLE_BACK);
}
}

public void setViewMediatorCallback(
KeyguardViewMediator.ViewMediatorCallback viewMediatorCallback) {
mViewMediatorCallback = viewMediatorCallback;
}

/**
* M: add for power-off alarm
*
* @return
*/
public abstract boolean isAlarmUnlockScreen();

}

更多相关文章

随机推荐

android 模拟滑动事件

更多相关文章

随机推荐

android　模拟滑动事件