| // Copyright 2016 The Fuchsia Authors. All rights reserved. |
| // Use of this source code is governed by a BSD-style license that can be |
| // found in the LICENSE file. |
| |
| library fuchsia.modular; |
| |
| using fuchsia.modular.auth; |
| using fuchsia.ui.viewsv1token; |
| using fuchsia.sys; |
| |
| // Given by the |Basemgr| to the |BaseShell| at Initialize() so the |
| // |BaseShell| can get information about the users of this device from the |
| // |Basemgr|, and act on the provided information (including extending the |
| // user database). |
| interface UserProvider { |
| // Adds information of a user that can be used to authenticate her/him to this |
| // device. Once successfully added, the user can login to the same device via |
| // Login(). |
| // |
| // |identity_provider| is the identity provider to use for identification. |
| // |
| // |device_name| is what the user wants to name the device. If null or empty |
| // the device's current hostname will be used. |
| // |
| // |account| is NULL if there was an error during identification and |
| // |error_code| is set. |
| 1: AddUser(fuchsia.modular.auth.IdentityProvider identity_provider) |
| -> (fuchsia.modular.auth.Account? account, string? error_code); |
| |
| // Removes information of a user from the local user database. |
| // |
| // |account_id| is received from either AddUser() or PreviousUsers(). |
| 2: RemoveUser(string account_id) -> (string? error_code); |
| |
| // Uses the credentials provided in AddUser() to start a user session. This |
| // would mean syncing with the user's ledger instance and displaying a user |
| // shell with all of the user's stories. |
| // TODO(alhaad): In the future, we want to protect Login() with a password, |
| // Android lock pattern, etc. |
| 3: Login(UserLoginParams user_login_params); |
| |
| // List of all users who have authenticated to this device in the past. |
| 4: PreviousUsers() -> (vector<fuchsia.modular.auth.Account> accounts); |
| }; |
| |
| // Used to specify arguments to log into a user session. |
| struct UserLoginParams { |
| // |account_id| is received from either AddUser() or PreviousUsers(). It |
| // can be NULL which means logging-in in an incognito mode. |
| string? account_id; |
| |
| // |view_owner| is the view given to the |SessionShell| started for the newly |
| // logged-in user. |
| request<fuchsia.ui.viewsv1token.ViewOwner> view_owner; |
| |
| // Services provided by the |BaseShell| that can be offered to the |
| // |SessionShell| that is being logged into. |
| fuchsia.sys.ServiceProvider? services; |
| |
| // If login fails, |user_controller| is closed. |
| request<UserController> user_controller; |
| }; |
| |
| // Provided by the |Basemgr| to the |BaseShell| when it authenticates a |
| // new user. This interface provides control to a logged-in user's life cycle, |
| // and the life of this interface is bound to a user being logged in. |
| // |
| // An interface similar to this one, |UserContext|, is provided to the user |
| // shell. It also contains a method to request logout. The difference is of |
| // level of ownership and control: |
| // |
| // - A controller interface to one component instance is given to a component |
| // instance which has control over the life cycle of the first component |
| // instance. As such, the controller interface can be used by the controlling |
| // component to change the life cycle of the controlled component. |
| // |
| // - A context interface to one component instance is given to a component |
| // instance whose life cycle is controlled by the first component instance. As |
| // such, the context interface can be used by the controlled component to |
| // request a change to its life cycle (among other functions). |
| // |
| // In general, the separation of a service |Foo| implemented by a component, and |
| // the service |FooController| given to the client of that component (rather |
| // than |Foo| directly) is a hallmark of inversion of control that pervades the |
| // design of our services. |
| interface UserController { |
| // Logs out a user by tearing down its sessionmgr. Returns once the |
| // Sessionmgr has been torn down. This also triggers OnLogout() for |
| // |UserWatcher|s. |
| 1: Logout() -> (); |
| |
| // Registers a watcher for the user's life cycle events. |
| 2: Watch(UserWatcher watcher); |
| |
| // Stops the currently running session shell and starts the one specified by |
| // |session_shell_config|. This operation stops all stories before starting |
| // the new shell. |
| 3: SwapSessionShell(AppConfig session_shell_config) -> (); |
| }; |
| |
| // Implemented by a |BaseShell| implementation in order to receive |
| // notification about life cycle changes of a logged in user. |
| interface UserWatcher { |
| // Called when a user has logged out, either by UserController.Logout() or by |
| // UserContext.Logout(). By the time this event is processed by a watcher, the |
| // Sessionmgr may already be torn down. |
| // |
| // TODO(vardhan): Make a guarantee that once OnLogout() is invoked, it is |
| // possible to UserProvider.Login() the same user. |
| 1: OnLogout(); |
| }; |