When build and run iOS app using Xcode, the phone becomes awake and app runs. Is there a way to wake and unlock Android phone (or tablet) screen then run installed Android app (Eclipse, Android Studio)?
One solution: set the following flags in your activity class(es):
if (BuildConfig.DEBUG) {
// These flags cause the device screen to turn on (and bypass screen guard if possible) when launching.
// This makes it easy for developers to test the app launch without needing to turn on the device
// each time and without needing to enable the "Stay awake" option.
getWindow().addFlags(WindowManager.LayoutParams.FLAG_TURN_SCREEN_ON
| WindowManager.LayoutParams.FLAG_DISMISS_KEYGUARD
| WindowManager.LayoutParams.FLAG_SHOW_WHEN_LOCKED);
}
These flags will:
Turn on the screen
Bypass the lock-screen
Allow showing the activity even if the device is locked
By setting those flags in your base activity, you'll be able to continue using your application even if the device was off and/or locked at the time of running. If you try to leave your application's process (i.e., hitting the home button, or switching to another app), the lock screen will appear, and you'll have to manually unlock to continue using the device.
Warning: this should only be used while developing/debugging your application, so I recommend keeping the if (BuildConfig.DEBUG) check, as it is in this example
Better and easiest solution is use the option (in development section) that the screen never goes off I thing the name is "Stay awake". This option prevent your phone to get locked when the usb cable is connected.
Another way is to write a script which runs before the app deploys and unlocks the device. This requires no app code change and will not change screen timeout which can have security implications.
You can find the full setup here
#!/bin/bash
# When a device is attached there will be atleast 3 lines -> heading, device details, an empty new line
if adb devices | wc -l | grep "3"; then
# Check if device locked, this may differ on some OEMs
if adb shell dumpsys window | grep "mInputRestricted=true"; then
echo "Device is Locked"
adb shell input keyevent KEYCODE_WAKEUP # wakeup device
adb shell input touchscreen swipe 530 1420 530 1120 # swipe up gesture
adb shell input text "000000" # <- Change to the your device PIN/Password
#adb shell input keyevent 66 # simulate press enter, if your keyguard requires it
else
echo "Device already unLocked"
fi
# 2 = Stay awake on USB, 0 = reset
adb shell settings put global stay_on_while_plugged_in 2
#adb shell settings put system screen_brightness 700
adb shell input keyevent KEYCODE_WAKEUP
adb shell input touchscreen tap 0 0 # this will wake up the screen and won't have any unwanted touches
else
echo "There should be only one device connected at a time"
fi
return 0
You cant unlock and wake the phone as that would not be very secure, however you can enable "Stay awake" in developer options.
Related
I'm trying to write a shellscript to create android emulators programatically (OS version >= 7.1.1), and I want those emulators to have a PIN but not "secure start-up".
Note that "secure start-up" is not the "lock screen" and also not the screen to unlock an encrypted device.
The secure start prevents android from booting without first inserting the PIN; lock screen is what appears after the boot up has finished.
Here's the description that shows up on Android 8.1 when you set the PIN manually on the emulator:
And what shows up when the emulator starts with the secure start-up activated:
I only managed to insert the PIN using the command:
adb -s <emulator_name> shell locksettings set-pin 1111
but this also activates the secure-start and I didn't find a way to deactivate it.
Do you know a command to deactivate only the secure-start and not the PIN? Thanks!
I need to know how to check if any type of screen lock is enabled in the settings part of the device. I need to check this using an adb command (by using adb shell). I also need to know the type of lock applied.
I have tried dumpsys but did not get any success.
I want to know if the screen lock is enabled in the settings even if the device is currently unlocked, just check if any security is there, in any state.
Has answered in Is there a way to check if Android device screen is locked via adb? - Stack Overflow and copy to here:
My Phone: XiaoMi 9
Android: 10
use adb to check status of screen locked
method 1: (universal) use mDreamingLockscreen
Command: adb shell dumpsys window | grep mDreamingLockscreen
Output:
mShowingDream=false mDreamingLockscreen=true mDreamingSleepToken=null -> Screen Locked
no matter Screen is ON or OFF
mShowingDream=false mDreamingLockscreen=false mDreamingSleepToken=null -> Scrren Unlocked
method 2: use nfc (if android has NFC module)
Command: adb shell dumpsys nfc | grep 'mScreenState='
Output:
mScreenState=OFF_LOCKED -> Screen OFF and Locked
mScreenState=ON_LOCKED -> Screen ON and Locked
mScreenState=ON_UNLOCKED -> Screen ON and Unlocked
I need to run some automated tests on an android device, the problem is that the screen needs to be unlocked first. I have tried:
input keyevent KEYCODE_MENU
But this hasn't worked.
I have access to a rooted device for this purpose and have removed the password. Just need a way to unlock the screen.
If you set your lock screen to none, you just need to send a power on command using adb.
# Switches on the android devices screen if it isn’t already on.
if `adb shell dumpsys input_method | grep mInteractive`.include? 'false'
`adb shell input keyevent KEYCODE_POWER`
end
# Pre lollipop devices respond to this command a bit differently.
if `adb shell dumpsys input_method | grep mScreenOn`.include? 'false'
`adb shell input keyevent KEYCODE_POWER`
end
The above will press the power button if the screen isn't already on.
How to wake up Android with use adb - I want to wake up (if asleep) Android terminal before debugging every new version of application.
Typical flow is:
1. I do some changes in Eclipse.
2. In the meantime screen goes off or not.
3. I run "debug" and want force screen to wake up.
I found a method with "power key" emulation but it does not turn it on but rather toggles the power state. I do not want to add extra code to my application. What are the other methods to do such trivial task, please help.
adb shell input keyevent KEYCODE_WAKEUP
As described here, this wakes up the device. Behaves somewhat like KEYCODE_POWER but it has no effect if the device is already awake.
To toggle sleep/wake with one command you can issue
adb shell input keyevent KEYCODE_POWER
Just use :
adb shell input keyevent 26
Here's what I came up with:
adb shell dumpsys power | grep "mScreenOn=true" | xargs -0 test -z && adb shell input keyevent 26
This will first check to see if the screen is on. If it isn't, it will emulate the power key, which will turn on the device's screen.
if you execute
adb shell input keyevent KEYCODE_POWER and got Killed, you should use root user by execute su before.
sleep:(adb shell) input keyevent KEYCODE_SLEEP
wakeup:(adb shell) input keyevent KEYCODE_WAKEUP
toggle:(adb shell) input keyevent KEYCODE_POWER
You can check device's current power state (including display) via adb with dumpsys power command and send the power key press event only if the display is off. The easier solution would be disabling the display timeout altogether "while connected to USB" in the Developer options.
you could also add the following flags to your onCreate() in your main activity:
getWindow().addFlags(WindowManager.LayoutParams.FLAG_DISMISS_KEYGUARD);
getWindow().addFlags(WindowManager.LayoutParams.FLAG_SHOW_WHEN_LOCKED);
getWindow().addFlags(WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON);
getWindow().addFlags(WindowManager.LayoutParams.FLAG_TURN_SCREEN_ON);
This way your device should wake up when it is loaded onto the device through Eclipse.
I know that this is the opposite of what the OP requested, but I wanted to point out the definition of "truly asleep" for other readers:
If adb is active, then the device is not truly asleep, since USB is on and the command prompt is running (how else is adb shell going to work?). When fully asleep, only the physical power button will wake it (unless other buttons are selected as a wake source in the BSP). My project draws about 120ma with screen off, but only 23ma in sleep mode (disconnect USB cable). "adb shell input keyevent 26" does not work in this mode. Neither does the serial console.
My test fixture does have access to the battery and external power line separately. I can toggle the power line (with battery connected) to wake it up. I also have a switched USB hub that disconnects the USB specifically for the sleep portion of the test.
I hope this can be some help to someone.
For Windows and Eclipse you can use .bat file:
#ECHO OFF
setlocal
for /f "delims= tokens=1*" %%a in ('adb shell dumpsys power ^| findstr.exe "mScreenOn="') DO (
for /f "delims== tokens=2*" %%S in ("%%a") do (
if "%%S" == "false" (goto move1) else (goto move2)
)
)
:move1
adb shell input keyevent 26
goto end
:move2
goto end
:end
exit
It will check, if screen is off it will switch the power state.
To use it with Eclipse this .bat file should be used as "External tool" (just fill the path to the .bat) and linked to the project in it's properties (Builders - Import - ).
I used the following to wake up remote devices for automated tests. If the screen isn't on, then it will press the power button followed by the menu button.
(
cd ${platform-tools};
./adb shell dumpsys power | grep -i 'SCREEN_ON' >/dev/null;
if [ $? -eq 0 ]; then
echo "Screen is on...";
else
echo "Pressing buttons to wake-up...";
# http://developer.android.com/reference/android/view/KeyEvent.html
./adb shell input keyevent 26; # Power
./adb shell input keyevent 82; # Menu
echo "Pausing for state to settle...";
sleep 1;
./adb shell dumpsys power | grep -i 'SCREEN_ON';
fi;
echo '---';
./adb shell dumpsys power | grep -i 'SCREEN'
)
How can I turn the sceen on ?
I tried something like this
adb -d shell am broadcast -a android.intent.action.SCREEN_ON
It really should work, I send broadcast intent it is received by the system, but the screen doesn't turn on
I do not understand what is the problem, is it possible to turn the screen of the device by code ? I mean with software ? Cause it seems like the turning on of the screen is done just by the hardware button press . . . at least I got that felling , am I wrong ?
adb shell input keyevent KEYCODE_POWER
Works to turn on screen (when display is off)
Works to turn off screen (when display is on/awake)
For Android 5.0 and above:
adb shell input keyevent KEYCODE_WAKEUP
or
adb shell input keyevent 224
KEYCODE_WAKEUP
Key code constant: Wakeup key. Wakes up the device. Behaves somewhat like KEYCODE_POWER but it has no effect if the device is already awake.
https://developer.android.com/reference/android/view/KeyEvent#KEYCODE_WAKEUP
Note: KEYCODE_POWER has been added in API level 1, while KEYCODE_WAKEUP has been added in API level 20!
u can turn it on/off if u do like:
adb shell
#shell: input keyevent 26
#shell: (enter or via hidden command empty line)
#shell: exit
this worked for me on some android versions ;)(NOTE: this will turn the screen on and off, depends on the actual screen state)
To detect the current state of the screen u can use the following ways:Android < 5.x.xadb shell dumpsys input_methodIn the output search for mScreenOn=true/false
Android >= 5.x.xadb shell dumpsys displayIn the output search for mScreenState=ON/OFF
In my scripts i use this \s{0,}mScreen(State|On)=(?<STATE>(true|false|on|off))\s{0,} (Compiled|IgnoreCase|ExplicitCapture) regular expression for both outputs to detect the current state.
EDIT (16.03.2018):
There is also another way to detect the screen state, it works since Android 3.0. The dumpsys window policy command will give us all we need. - In the output search for mScreenOn(Fully)?=(?<STATE>(true|false)).
There are also other useful informations like:
mUnrestrictedScreen (value is like: (0,0) 768x1280)
mRestrictedScreen (value is like: (0,0) 768x1184)
Regards,
k1ll3r8e
I could be wrong about this, but...
You shouldn't think of broadcasts as something to send to get things done, but instead think of them as things that are sent when things are done.
I think the system sends 'android.intent.action.SCREEN_ON' when screen is goes on, but sending 'android.intent.action.SCREEN_ON' does not necessarily make the screen go on.
I hope this makes sense.
For the answer, you can find it in...
Calling hidden API in android to turn screen off
turn the screen on/off in Android with a shake
The command to toggle the screen on/off is:
adb shell input keyevent 26
This condensed command is preferred because it allows you to use it in scripts.
Cheers!
this works in android 12
#!/bin/bash
screenState=$(adb shell dumpsys window policy | grep screenState=SCREEN_STATE_ | cut -c 32-)
if [ "$screenState" == "OFF" ]; then
adb shell input keyevent KEYCODE_POWER
fi