1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
|
// Copyright 2014 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#ifndef ASH_MULTI_USER_USER_SWITCH_ANIMATOR_H_
#define ASH_MULTI_USER_USER_SWITCH_ANIMATOR_H_
#include <map>
#include <memory>
#include <string>
#include "ash/ash_export.h"
#include "base/memory/raw_ptr.h"
#include "base/time/time.h"
#include "base/timer/timer.h"
#include "components/account_id/account_id.h"
#include "ui/aura/window.h"
namespace ash {
class MultiUserWindowManagerImpl;
// A class which performs transitions animations between users. Upon creation,
// the animation gets started and upon destruction the animation gets finished
// if not done yet.
// Specifying |animation_disabled| upon creation will perform the transition
// without visible animations.
class ASH_EXPORT UserSwitchAnimator {
public:
// The animation step for the user change animation.
enum AnimationStep {
ANIMATION_STEP_HIDE_OLD_USER, // Hiding the old user (and shelf).
ANIMATION_STEP_SHOW_NEW_USER, // Show the shelf of the new user.
ANIMATION_STEP_FINALIZE, // All animations are done - final cleanup.
ANIMATION_STEP_ENDED // The animation has ended.
};
// Creates a UserSwitchAnimator to animate between the current user and the
// user associated with |new_account_id|.
UserSwitchAnimator(MultiUserWindowManagerImpl* owner,
const AccountId& new_account_id,
base::TimeDelta animation_speed);
UserSwitchAnimator(const UserSwitchAnimator&) = delete;
UserSwitchAnimator& operator=(const UserSwitchAnimator&) = delete;
~UserSwitchAnimator();
// Check if a window is covering the entire work area of the screen it is on.
static bool CoversScreen(aura::Window* window);
bool IsAnimationFinished() { return animation_step_ == ANIMATION_STEP_ENDED; }
// Returns the user id for which the wallpaper is currently shown.
// If a wallpaper is transitioning to B it will be returned as "->B".
const std::string& wallpaper_user_id_for_test() {
return wallpaper_user_id_for_test_;
}
// Advances the user switch animation to the next step. It reads the current
// step from |animation_step_| and increments it thereafter. When
// |ANIMATION_STEP_FINALIZE| gets executed, the animation is finished and the
// timer (if one exists) will get destroyed.
void AdvanceUserTransitionAnimation();
// When the system is shutting down, the animation can be stopped without
// ending it.
void CancelAnimation();
private:
// The window configuration of screen covering windows before an animation.
enum TransitioningScreenCover {
NO_USER_COVERS_SCREEN, // No window covers the entire screen.
OLD_USER_COVERS_SCREEN, // The current user has at least one window
// covering the entire screen.
NEW_USER_COVERS_SCREEN, // The user which becomes active has at least one
// window covering the entire screen.
BOTH_USERS_COVER_SCREEN // Both users have at least one window each
// covering the entire screen.
};
// Finalizes the animation and ends the timer (if there is one).
void FinalizeAnimation();
// Execute the user wallpaper animations for |animation_step|.
void TransitionWallpaper(AnimationStep animtion_step);
// Update the shelf for |animation_step|.
void TransitionUserShelf(AnimationStep animtion_step);
// Execute the window animations for |animation_step|.
void TransitionWindows(AnimationStep animation_step);
// Check if a window is maximized / fullscreen / covering the entire screen.
// If a |root_window| is given, the screen coverage of that root_window is
// tested, otherwise all screens.
TransitioningScreenCover GetScreenCover(aura::Window* root_window);
// Builds the map that a user ID to the list of windows that should be shown
// for this user. This operation happens once upon the construction of this
// animation.
void BuildUserToWindowsListMap();
// The owning window manager.
raw_ptr<MultiUserWindowManagerImpl, ExperimentalAsh> owner_;
// The new user to set.
AccountId new_account_id_;
// The animation speed in ms. If 0, animations are disabled.
base::TimeDelta animation_speed_;
// The next animation step for AdvanceUserTransitionAnimation().
AnimationStep animation_step_;
// The screen cover status before the animation has started.
const TransitioningScreenCover screen_cover_;
// Mapping users IDs to the list of windows to show for these users.
typedef std::map<AccountId, aura::Window::Windows> UserToWindowsMap;
UserToWindowsMap windows_by_account_id_;
// A timer which watches to executes the second part of a "user changed"
// animation. Note that this timer exists only during such an animation.
std::unique_ptr<base::RepeatingTimer> user_changed_animation_timer_;
// For unit tests: Check which wallpaper was set.
std::string wallpaper_user_id_for_test_;
};
} // namespace ash
#endif // ASH_MULTI_USER_USER_SWITCH_ANIMATOR_H_
|
