// Copyright 2017 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
syntax = "proto2";
package ash.power.ml;
option optimize_for = LITE_RUNTIME;
// This proto will represent one logged event to be used as a training example.
// It contains both features and labels.
message UserActivityEvent {
message ModelParams {
// Event logging will be triggered after inactivity of start_delay_sec.
// Value will be in the range of 10sec - 20sec, which may be tuned following
// experiments.
optional int32 start_delay_sec = 1;
// timeout_delay_sec defines extended idle period following screen-off, at
// which point we will log event type to be TIMEOUT. Value will be ~10sec or
// shorter, which may be tuned following experiments.
optional int32 timeout_delay_sec = 2;
}
// Event describes what happens after user is inactive for start_delay_sec. It
// will be used as training labels.
message Event {
// Event type describes whether user reactivates or turns off the system or
// remains idle until model times out. This will be used as labels.
enum Type {
REACTIVATE = 1;
OFF = 2;
TIMEOUT = 3;
}
optional Type type = 1;
// Trigger of the event. They won't be used as labels and will be used for
// analysis only.
enum Reason {
USER_ACTIVITY = 1;
VIDEO_ACTIVITY = 2;
POWER_CHANGED = 3;
LID_CLOSED = 4;
SHUTDOWN = 5;
SESSION_STOPPED = 6;
SCREEN_OFF = 7;
SCREEN_LOCK = 8;
IDLE_SLEEP = 9;
MANUAL_SLEEP = 10;
}
optional Reason reason = 2;
// Time taken in seconds from when we start logging the features to the
// moment when the event type is known and we finish logging the complete
// event.
optional int32 log_duration_sec = 3;
// Whether screen dim/off occurred before final event was logged.
// Screen should be on (not dimmed not turned off) when an idle event is
// reported because we report idle event after a short period of inactivity,
// which isn't long enough for screen to be dimmed. However, in the unlikely
// event that screen is dimmed when an idle event is reported,
// |screen_dim_occurred| is true only if screen is subsequently turned on
// and dimmed again. In other words, if screen remains dimmed,
// |screen_dim_occurred| will be false. Similar logic for
// |screen_off_occurred|.
optional bool screen_dim_occurred = 4;
optional bool screen_off_occurred = 5;
// Whether screen lock occurred before final event was logged.
optional bool screen_lock_occurred = 6;
}
message Features {
// Time taken to transition between states.
optional int32 on_to_dim_sec = 1;
optional int32 dim_to_screen_off_sec = 2;
// Last activity and last user activity as seconds since midnight in the
// local time zone. Last activity may not be user-related, e.g. it may be a
// video-playing activity. Below we record both general activity time and
// user activity time.
optional int32 last_activity_time_sec = 3;
optional int32 last_user_activity_time_sec = 4;
// This must match the week range in base::Time::Exploded.
enum DayOfWeek {
SUN = 0;
MON = 1;
TUE = 2;
WED = 3;
THU = 4;
FRI = 5;
SAT = 6;
}
optional DayOfWeek last_activity_day = 5;
// Time from last mouse/key event to when the logging starts (for training
// data generation). This may not be the same as start_delay_sec, depending
// on what the last activity is.
optional int32 time_since_last_mouse_sec = 6;
optional int32 time_since_last_key_sec = 7;
optional int32 time_since_last_touch_sec = 21;
// Duration of activity (user or video) up to last_activity_time_sec. If
// activity starts at time t1, then recent_time_active_sec =
// |last_activity_time_sec - t1|. We ignore short periods of idle time (i.e.
// user is considered active in this idle period), but the short periods
// must be shorter than start_delay_sec.
// TODO(jiameng): we may consider a different way of measuring continued
// activity following experiments.
optional int32 recent_time_active_sec = 8;
// At the moment, we only log events when device is Chromebook, hence we
// ignore types such as Chromebase, Chromebit and Chromebox.
enum DeviceType {
UNKNOWN_DEVICE = 0;
CHROMEBOOK = 1;
}
optional DeviceType device_type = 9;
// Device mode.
enum DeviceMode {
UNKNOWN_MODE = 0;
// Lid is closed.
CLOSED_LID = 1;
// Lid is open, tablet mode is off or unsupported.
CLAMSHELL = 2;
// Lid is open, tablet mode is on or no lid at all.
TABLET = 3;
}
optional DeviceMode device_mode = 10;
optional float battery_percent = 11;
optional bool on_battery = 12;
// Whether user/device is managed.
enum ManagementType {
UNKNOWN_MANAGEMENT = 0;
MANAGED = 1;
UNMANAGED = 2;
}
optional ManagementType user_management = 13;
optional ManagementType device_management = 14;
// Whether network is connected.
optional bool is_online = 15;
// Duration of latest non-stop video playing before the current idle
// event. If a video paused/stopped temporarily (i.e. less than
// start_delay_sec), we consider it as non-stop.
optional int32 video_playing_time_sec = 16;
// Duration from the time video ended to the time of idle event.
optional int32 time_since_video_ended_sec = 17;
// Number of key/mouse/touch events in the past hour.
optional int32 key_events_in_last_hour = 18;
optional int32 mouse_events_in_last_hour = 19;
optional int32 touch_events_in_last_hour = 20;
// Whether screen was dimmed/turned off when an idle event was reported.
optional bool screen_dimmed_initially = 22;
optional bool screen_off_initially = 23;
optional bool screen_locked_initially = 24;
// Properties associated with the active tab of the visible focused/topmost
// browser. Unset if there's no such tab.
optional int32 engagement_score = 25;
optional bool has_form_entry = 26;
optional int64 source_id = 27;
// A valid URL could still have empty domain.
optional string tab_domain = 28;
// Number of times user reactivated and thus undimmed the screen before
// system was suspended.
optional int32 previous_negative_actions_count = 29;
// Number of times user remained idle after dim until system was suspended
// or closed.
optional int32 previous_positive_actions_count = 30;
} // next id = 31
// All fields except |model_applied| in ModelPrediction are populated by the
// model. |model_applied| is populated by the UserActivityManager when
// deciding whether to apply the model decision.
message ModelPrediction {
enum Response {
// Dim should go ahead.
DIM = 0;
// Dim should be deferred.
NO_DIM = 1;
// Model could fail to make a prediction due to various reasons, e.g. it
// could fail to load the preprocessor or process the features for
// inference.
MODEL_ERROR = 2;
}
// Both |inactivity_score| and |decision_threshold| are in the range of
// [0,100]. These values are the quantized versions of actual values used in
// making a model prediction, so that they can be logged later. If
// |inactivity_score| < |decision_threshold| then dim will be deferred.
optional int32 decision_threshold = 1;
// How likely user will remain inactive if screen is dimmed.
optional int32 inactivity_score = 2;
// Whether model decision (regardless if dim is to be deferred) is
// taken by powerd. It is false if model response is MODEL_ERROR or if dim
// was deferred last time dim imminent occurred.
optional bool model_applied = 3;
optional Response response = 4;
}
optional ModelParams params = 1;
optional Event event = 2;
optional Features features = 3;
// Unset if model prediction is disabled in an experiment.
optional ModelPrediction model_prediction = 4;
}
Codebase Browser
chromium