zulip/web/src/activity.js

354 lines
10 KiB
JavaScript

import $ from "jquery";
import _ from "lodash";
import * as blueslip from "./blueslip";
import * as buddy_data from "./buddy_data";
import {buddy_list} from "./buddy_list";
import * as channel from "./channel";
import * as keydown_util from "./keydown_util";
import {ListCursor} from "./list_cursor";
import * as narrow from "./narrow";
import {page_params} from "./page_params";
import * as people from "./people";
import * as pm_list from "./pm_list";
import * as popovers from "./popovers";
import * as presence from "./presence";
import * as ui_util from "./ui_util";
import {UserSearch} from "./user_search";
import * as util from "./util";
import * as watchdog from "./watchdog";
export let user_cursor;
export let user_filter;
/*
Helpers for detecting user activity and managing user idle states
*/
/* Broadcast "idle" to server after 5 minutes of local inactivity */
const DEFAULT_IDLE_TIMEOUT_MS = 5 * 60 * 1000;
/* Keep in sync with views.py:update_active_status_backend() */
export const ACTIVE = "active";
export const IDLE = "idle";
// When you open Zulip in a new browser window, client_is_active
// should be true. When a server-initiated reload happens, however,
// it should be initialized to false. We handle this with a check for
// whether the window is focused at initialization time.
export let client_is_active = document.hasFocus && document.hasFocus();
// new_user_input is a more strict version of client_is_active used
// primarily for analytics. We initialize this to true, to count new
// page loads, but set it to false in the onload function in reload.js
// if this was a server-initiated-reload to avoid counting a
// server-initiated reload as user activity.
export let new_user_input = true;
export function set_new_user_input(value) {
new_user_input = value;
}
function get_pm_list_item(user_id) {
return buddy_list.find_li({
key: user_id,
});
}
function set_pm_count(user_ids_string, count) {
const $pm_li = get_pm_list_item(user_ids_string);
ui_util.update_unread_count_in_dom($pm_li, count);
}
export function update_dom_with_unread_counts(counts) {
// counts is just a data object that gets calculated elsewhere
// Our job is to update some DOM elements.
for (const [user_ids_string, count] of counts.pm_count) {
// TODO: just use user_ids_string in our markup
const is_pm = !user_ids_string.includes(",");
if (is_pm) {
set_pm_count(user_ids_string, count);
}
}
}
export function clear_for_testing() {
user_cursor = undefined;
user_filter = undefined;
client_is_active = false;
}
export function mark_client_idle() {
// When we become idle, we don't immediately send anything to the
// server; instead, we wait for our next periodic update, since
// this data is fundamentally not timely.
client_is_active = false;
}
export function redraw_user(user_id) {
if (page_params.realm_presence_disabled) {
return;
}
const filter_text = get_filter_text();
if (!buddy_data.matches_filter(filter_text, user_id)) {
return;
}
const info = buddy_data.get_item(user_id);
buddy_list.insert_or_move({
key: user_id,
item: info,
});
}
export function searching() {
return user_filter && user_filter.searching();
}
export function build_user_sidebar() {
if (page_params.realm_presence_disabled) {
return undefined;
}
const filter_text = get_filter_text();
const user_ids = buddy_data.get_filtered_and_sorted_user_ids(filter_text);
buddy_list.populate({keys: user_ids});
return user_ids; // for testing
}
function do_update_users_for_search() {
// Hide all the popovers but not userlist sidebar
// when the user is searching.
popovers.hide_all_except_sidebars();
build_user_sidebar();
user_cursor.reset();
}
const update_users_for_search = _.throttle(do_update_users_for_search, 50);
export function compute_active_status() {
// The overall algorithm intent for the `status` field is to send
// `ACTIVE` (aka green circle) if we know the user is at their
// computer, and IDLE (aka orange circle) if the user might not
// be:
//
// * For the web app, we just know whether this window has focus.
// * For the electron desktop app, we also know whether the
// user is active or idle elsewhere on their system.
//
// The check for `get_idle_on_system === undefined` is feature
// detection; older desktop app releases never set that property.
if (
window.electron_bridge !== undefined &&
window.electron_bridge.get_idle_on_system !== undefined
) {
if (window.electron_bridge.get_idle_on_system()) {
return IDLE;
}
return ACTIVE;
}
if (client_is_active) {
return ACTIVE;
}
return IDLE;
}
export function send_presence_to_server(want_redraw) {
// Zulip has 2 data feeds coming from the server to the client:
// The server_events data, and this presence feed. Data from
// server_events is nicely serialized, but if we've been offline
// and not running for a while (e.g. due to suspend), we can end
// up with inconsistent state where users appear in presence that
// don't appear in people.js. We handle this in 2 stages. First,
// here, we trigger an extra run of the clock-jump check that
// detects whether this device just resumed from suspend. This
// ensures that watchdog.suspect_offline is always up-to-date
// before we initiate a presence request.
//
// If we did just resume, it will also trigger an immediate
// server_events request to the server (the success handler to
// which will clear suspect_offline and potentially trigger a
// reload if the device was offline for more than
// DEFAULT_EVENT_QUEUE_TIMEOUT_SECS).
if (page_params.is_spectator) {
return;
}
watchdog.check_for_unsuspend();
channel.post({
url: "/json/users/me/presence",
data: {
status: compute_active_status(),
ping_only: !want_redraw,
new_user_input,
slim_presence: true,
},
success(data) {
// Update Zephyr mirror activity warning
if (data.zephyr_mirror_active === false) {
$("#zephyr-mirror-error").addClass("show");
} else {
$("#zephyr-mirror-error").removeClass("show");
}
new_user_input = false;
if (want_redraw) {
presence.set_info(data.presences, data.server_timestamp);
redraw();
}
},
});
}
export function mark_client_active() {
// exported for testing
if (!client_is_active) {
client_is_active = true;
send_presence_to_server(false);
}
}
export function initialize() {
$("html").on("mousemove", () => {
new_user_input = true;
});
$(window).on("focus", mark_client_active);
$(window).idle({
idle: DEFAULT_IDLE_TIMEOUT_MS,
onIdle: mark_client_idle,
onActive: mark_client_active,
keepTracking: true,
});
set_cursor_and_filter();
build_user_sidebar();
buddy_list.start_scroll_handler();
function get_full_presence_list_update() {
send_presence_to_server(true);
}
/* Time between keep-alive pings */
const active_ping_interval_ms = page_params.server_presence_ping_interval_seconds * 1000;
util.call_function_periodically(get_full_presence_list_update, active_ping_interval_ms);
// Let the server know we're here, but pass "false" for
// want_redraw, since we just got all this info in page_params.
send_presence_to_server(false);
}
export function update_presence_info(user_id, info, server_time) {
presence.update_info_from_event(user_id, info, server_time);
redraw_user(user_id);
pm_list.update_private_messages();
}
export function redraw() {
build_user_sidebar();
user_cursor.redraw();
pm_list.update_private_messages();
}
export function reset_users() {
// Call this when we're leaving the search widget.
build_user_sidebar();
user_cursor.clear();
}
export function narrow_for_user(opts) {
const user_id = buddy_list.get_key_from_li({$li: opts.$li});
return narrow_for_user_id({user_id});
}
export function narrow_for_user_id(opts) {
const person = people.get_by_user_id(opts.user_id);
const email = person.email;
narrow.by("dm", email, {trigger: "sidebar"});
user_filter.clear_and_hide_search();
}
function keydown_enter_key() {
const user_id = user_cursor.get_key();
if (user_id === undefined) {
return;
}
narrow_for_user_id({user_id});
popovers.hide_all();
}
export function set_cursor_and_filter() {
user_cursor = new ListCursor({
list: buddy_list,
highlight_class: "highlighted_user",
});
user_filter = new UserSearch({
update_list: update_users_for_search,
reset_items: reset_users,
on_focus: () => user_cursor.reset(),
});
const $input = user_filter.input_field();
$input.on("blur", () => user_cursor.clear());
keydown_util.handle({
$elem: $input,
handlers: {
Enter() {
keydown_enter_key();
return true;
},
ArrowUp() {
user_cursor.prev();
return true;
},
ArrowDown() {
user_cursor.next();
return true;
},
},
});
}
export function initiate_search() {
if (user_filter) {
user_filter.initiate_search();
}
}
export function escape_search() {
if (user_filter) {
user_filter.escape_search();
}
}
export function get_filter_text() {
if (!user_filter) {
// This may be overly defensive, but there may be
// situations where get called before everything is
// fully initialized. The empty string is a fine
// default here.
blueslip.warn("get_filter_text() is called before initialization");
return "";
}
return user_filter.text();
}