You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
293 lines
13 KiB
293 lines
13 KiB
/*
|
|
* Copyright (C) 2021 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.
|
|
*/
|
|
|
|
#include <gtest/gtest.h>
|
|
|
|
#include "../FocusResolver.h"
|
|
|
|
#define ASSERT_FOCUS_CHANGE(_changes, _oldFocus, _newFocus) \
|
|
{ \
|
|
ASSERT_EQ(_oldFocus, _changes->oldFocus); \
|
|
ASSERT_EQ(_newFocus, _changes->newFocus); \
|
|
}
|
|
|
|
// atest inputflinger_tests:FocusResolverTest
|
|
|
|
namespace android::inputdispatcher {
|
|
|
|
class FakeWindowHandle : public InputWindowHandle {
|
|
public:
|
|
FakeWindowHandle(const std::string& name, const sp<IBinder>& token, bool focusable,
|
|
bool visible) {
|
|
mInfo.token = token;
|
|
mInfo.name = name;
|
|
mInfo.visible = visible;
|
|
mInfo.focusable = focusable;
|
|
}
|
|
|
|
bool updateInfo() { return true; }
|
|
void setFocusable(bool focusable) { mInfo.focusable = focusable; }
|
|
void setVisible(bool visible) { mInfo.visible = visible; }
|
|
};
|
|
|
|
TEST(FocusResolverTest, SetFocusedWindow) {
|
|
sp<IBinder> focusableWindowToken = new BBinder();
|
|
sp<IBinder> invisibleWindowToken = new BBinder();
|
|
sp<IBinder> unfocusableWindowToken = new BBinder();
|
|
std::vector<sp<InputWindowHandle>> windows;
|
|
windows.push_back(new FakeWindowHandle("Focusable", focusableWindowToken, true /* focusable */,
|
|
true /* visible */));
|
|
windows.push_back(new FakeWindowHandle("Invisible", invisibleWindowToken, true /* focusable */,
|
|
false /* visible */));
|
|
windows.push_back(new FakeWindowHandle("unfocusable", unfocusableWindowToken,
|
|
false /* focusable */, true /* visible */));
|
|
|
|
// focusable window can get focused
|
|
FocusRequest request;
|
|
request.displayId = 42;
|
|
request.token = focusableWindowToken;
|
|
FocusResolver focusResolver;
|
|
std::optional<FocusResolver::FocusChanges> changes =
|
|
focusResolver.setFocusedWindow(request, windows);
|
|
ASSERT_FOCUS_CHANGE(changes, /*from*/ nullptr, /*to*/ focusableWindowToken);
|
|
ASSERT_EQ(request.displayId, changes->displayId);
|
|
|
|
// invisible window cannot get focused
|
|
request.token = invisibleWindowToken;
|
|
changes = focusResolver.setFocusedWindow(request, windows);
|
|
ASSERT_EQ(focusableWindowToken, changes->oldFocus);
|
|
ASSERT_EQ(nullptr, changes->newFocus);
|
|
ASSERT_FOCUS_CHANGE(changes, /*from*/ focusableWindowToken, /*to*/ nullptr);
|
|
|
|
// unfocusableWindowToken window cannot get focused
|
|
request.token = unfocusableWindowToken;
|
|
changes = focusResolver.setFocusedWindow(request, windows);
|
|
ASSERT_FALSE(changes);
|
|
}
|
|
|
|
TEST(FocusResolverTest, SetFocusedMirroredWindow) {
|
|
sp<IBinder> focusableWindowToken = new BBinder();
|
|
sp<IBinder> invisibleWindowToken = new BBinder();
|
|
sp<IBinder> unfocusableWindowToken = new BBinder();
|
|
std::vector<sp<InputWindowHandle>> windows;
|
|
windows.push_back(new FakeWindowHandle("Mirror1", focusableWindowToken, true /* focusable */,
|
|
true /* visible */));
|
|
windows.push_back(new FakeWindowHandle("Mirror1", focusableWindowToken, true /* focusable */,
|
|
true /* visible */));
|
|
|
|
windows.push_back(new FakeWindowHandle("Mirror2Visible", invisibleWindowToken,
|
|
true /* focusable */, true /* visible */));
|
|
windows.push_back(new FakeWindowHandle("Mirror2Invisible", invisibleWindowToken,
|
|
true /* focusable */, false /* visible */));
|
|
|
|
windows.push_back(new FakeWindowHandle("Mirror3Focusable", unfocusableWindowToken,
|
|
true /* focusable */, true /* visible */));
|
|
windows.push_back(new FakeWindowHandle("Mirror3Unfocusable", unfocusableWindowToken,
|
|
false /* focusable */, true /* visible */));
|
|
|
|
// mirrored window can get focused
|
|
FocusRequest request;
|
|
request.displayId = 42;
|
|
request.token = focusableWindowToken;
|
|
FocusResolver focusResolver;
|
|
std::optional<FocusResolver::FocusChanges> changes =
|
|
focusResolver.setFocusedWindow(request, windows);
|
|
ASSERT_FOCUS_CHANGE(changes, /*from*/ nullptr, /*to*/ focusableWindowToken);
|
|
|
|
// mirrored window with one visible window can get focused
|
|
request.token = invisibleWindowToken;
|
|
changes = focusResolver.setFocusedWindow(request, windows);
|
|
ASSERT_FOCUS_CHANGE(changes, /*from*/ focusableWindowToken, /*to*/ invisibleWindowToken);
|
|
|
|
// mirrored window with one or more unfocusable window cannot get focused
|
|
request.token = unfocusableWindowToken;
|
|
changes = focusResolver.setFocusedWindow(request, windows);
|
|
ASSERT_FOCUS_CHANGE(changes, /*from*/ invisibleWindowToken, /*to*/ nullptr);
|
|
}
|
|
|
|
TEST(FocusResolverTest, SetInputWindows) {
|
|
sp<IBinder> focusableWindowToken = new BBinder();
|
|
std::vector<sp<InputWindowHandle>> windows;
|
|
sp<FakeWindowHandle> window = new FakeWindowHandle("Focusable", focusableWindowToken,
|
|
true /* focusable */, true /* visible */);
|
|
windows.push_back(window);
|
|
|
|
// focusable window can get focused
|
|
FocusRequest request;
|
|
request.displayId = 42;
|
|
request.token = focusableWindowToken;
|
|
FocusResolver focusResolver;
|
|
std::optional<FocusResolver::FocusChanges> changes =
|
|
focusResolver.setFocusedWindow(request, windows);
|
|
ASSERT_EQ(focusableWindowToken, changes->newFocus);
|
|
|
|
// Window visibility changes and the window loses focus
|
|
window->setVisible(false);
|
|
changes = focusResolver.setInputWindows(request.displayId, windows);
|
|
ASSERT_FOCUS_CHANGE(changes, /*from*/ focusableWindowToken, /*to*/ nullptr);
|
|
}
|
|
|
|
TEST(FocusResolverTest, FocusRequestsCanBePending) {
|
|
sp<IBinder> invisibleWindowToken = new BBinder();
|
|
std::vector<sp<InputWindowHandle>> windows;
|
|
|
|
sp<FakeWindowHandle> invisibleWindow =
|
|
new FakeWindowHandle("Invisible", invisibleWindowToken, true /* focusable */,
|
|
false /* visible */);
|
|
windows.push_back(invisibleWindow);
|
|
|
|
// invisible window cannot get focused
|
|
FocusRequest request;
|
|
request.displayId = 42;
|
|
request.token = invisibleWindowToken;
|
|
FocusResolver focusResolver;
|
|
std::optional<FocusResolver::FocusChanges> changes =
|
|
focusResolver.setFocusedWindow(request, windows);
|
|
ASSERT_FALSE(changes);
|
|
|
|
// Window visibility changes and the window gets focused
|
|
invisibleWindow->setVisible(true);
|
|
changes = focusResolver.setInputWindows(request.displayId, windows);
|
|
ASSERT_FOCUS_CHANGE(changes, /*from*/ nullptr, /*to*/ invisibleWindowToken);
|
|
}
|
|
|
|
TEST(FocusResolverTest, FocusRequestsArePersistent) {
|
|
sp<IBinder> windowToken = new BBinder();
|
|
std::vector<sp<InputWindowHandle>> windows;
|
|
|
|
sp<FakeWindowHandle> window = new FakeWindowHandle("Test Window", windowToken,
|
|
false /* focusable */, true /* visible */);
|
|
windows.push_back(window);
|
|
|
|
// non-focusable window cannot get focused
|
|
FocusRequest request;
|
|
request.displayId = 42;
|
|
request.token = windowToken;
|
|
FocusResolver focusResolver;
|
|
std::optional<FocusResolver::FocusChanges> changes =
|
|
focusResolver.setFocusedWindow(request, windows);
|
|
ASSERT_FALSE(changes);
|
|
|
|
// Focusability changes and the window gets focused
|
|
window->setFocusable(true);
|
|
changes = focusResolver.setInputWindows(request.displayId, windows);
|
|
ASSERT_FOCUS_CHANGE(changes, /*from*/ nullptr, /*to*/ windowToken);
|
|
|
|
// Visibility changes and the window loses focus
|
|
window->setVisible(false);
|
|
changes = focusResolver.setInputWindows(request.displayId, windows);
|
|
ASSERT_FOCUS_CHANGE(changes, /*from*/ windowToken, /*to*/ nullptr);
|
|
|
|
// Visibility changes and the window gets focused
|
|
window->setVisible(true);
|
|
changes = focusResolver.setInputWindows(request.displayId, windows);
|
|
ASSERT_FOCUS_CHANGE(changes, /*from*/ nullptr, /*to*/ windowToken);
|
|
|
|
// Window is gone and the window loses focus
|
|
changes = focusResolver.setInputWindows(request.displayId, {});
|
|
ASSERT_FOCUS_CHANGE(changes, /*from*/ windowToken, /*to*/ nullptr);
|
|
|
|
// Window returns and the window gains focus
|
|
changes = focusResolver.setInputWindows(request.displayId, windows);
|
|
ASSERT_FOCUS_CHANGE(changes, /*from*/ nullptr, /*to*/ windowToken);
|
|
}
|
|
|
|
TEST(FocusResolverTest, ConditionalFocusRequestsAreNotPersistent) {
|
|
sp<IBinder> hostWindowToken = new BBinder();
|
|
std::vector<sp<InputWindowHandle>> windows;
|
|
|
|
sp<FakeWindowHandle> hostWindow =
|
|
new FakeWindowHandle("Host Window", hostWindowToken, true /* focusable */,
|
|
true /* visible */);
|
|
windows.push_back(hostWindow);
|
|
sp<IBinder> embeddedWindowToken = new BBinder();
|
|
sp<FakeWindowHandle> embeddedWindow =
|
|
new FakeWindowHandle("Embedded Window", embeddedWindowToken, true /* focusable */,
|
|
true /* visible */);
|
|
windows.push_back(embeddedWindow);
|
|
|
|
FocusRequest request;
|
|
request.displayId = 42;
|
|
request.token = hostWindowToken;
|
|
FocusResolver focusResolver;
|
|
std::optional<FocusResolver::FocusChanges> changes =
|
|
focusResolver.setFocusedWindow(request, windows);
|
|
ASSERT_FOCUS_CHANGE(changes, /*from*/ nullptr, /*to*/ hostWindowToken);
|
|
|
|
request.focusedToken = hostWindow->getToken();
|
|
request.token = embeddedWindowToken;
|
|
changes = focusResolver.setFocusedWindow(request, windows);
|
|
ASSERT_FOCUS_CHANGE(changes, /*from*/ hostWindowToken, /*to*/ embeddedWindowToken);
|
|
|
|
embeddedWindow->setFocusable(false);
|
|
changes = focusResolver.setInputWindows(request.displayId, windows);
|
|
// The embedded window is no longer focusable, provide focus back to the original focused
|
|
// window.
|
|
ASSERT_FOCUS_CHANGE(changes, /*from*/ embeddedWindowToken, /*to*/ hostWindowToken);
|
|
|
|
embeddedWindow->setFocusable(true);
|
|
changes = focusResolver.setInputWindows(request.displayId, windows);
|
|
// The embedded window is focusable again, but we it cannot gain focus unless there is another
|
|
// focus request.
|
|
ASSERT_FALSE(changes);
|
|
|
|
embeddedWindow->setVisible(false);
|
|
changes = focusResolver.setFocusedWindow(request, windows);
|
|
// If the embedded window is not visible/focusable, then we do not grant it focus and the
|
|
// request is dropped.
|
|
ASSERT_FALSE(changes);
|
|
|
|
embeddedWindow->setVisible(true);
|
|
changes = focusResolver.setInputWindows(request.displayId, windows);
|
|
// If the embedded window becomes visble/focusable, nothing changes since the request has been
|
|
// dropped.
|
|
ASSERT_FALSE(changes);
|
|
}
|
|
TEST(FocusResolverTest, FocusRequestsAreClearedWhenWindowIsRemoved) {
|
|
sp<IBinder> windowToken = new BBinder();
|
|
std::vector<sp<InputWindowHandle>> windows;
|
|
|
|
sp<FakeWindowHandle> window = new FakeWindowHandle("Test Window", windowToken,
|
|
true /* focusable */, true /* visible */);
|
|
windows.push_back(window);
|
|
|
|
FocusRequest request;
|
|
request.displayId = 42;
|
|
request.token = windowToken;
|
|
FocusResolver focusResolver;
|
|
std::optional<FocusResolver::FocusChanges> changes =
|
|
focusResolver.setFocusedWindow(request, windows);
|
|
ASSERT_FOCUS_CHANGE(changes, /*from*/ nullptr, /*to*/ windowToken);
|
|
ASSERT_EQ(request.displayId, changes->displayId);
|
|
|
|
// Start with a focused window
|
|
window->setFocusable(true);
|
|
changes = focusResolver.setInputWindows(request.displayId, windows);
|
|
ASSERT_FOCUS_CHANGE(changes, /*from*/ nullptr, /*to*/ windowToken);
|
|
|
|
// When a display is removed, all windows are removed from the display
|
|
// and our focused window loses focus
|
|
changes = focusResolver.setInputWindows(request.displayId, {});
|
|
ASSERT_FOCUS_CHANGE(changes, /*from*/ windowToken, /*to*/ nullptr);
|
|
focusResolver.displayRemoved(request.displayId);
|
|
|
|
// When a display is readded, the window does not get focus since the request was cleared.
|
|
changes = focusResolver.setInputWindows(request.displayId, windows);
|
|
ASSERT_FALSE(changes);
|
|
}
|
|
|
|
} // namespace android::inputdispatcher
|