Linux + iPhone Continuity / iMessage / SMS
#include "contacts_view.hpp"
#include "daemon_client.hpp"
#include "ui_util.hpp"
#include <tether/i18n.hpp>
#include <cstring>
#include <string>
namespace tether::ui {
namespace {
struct ContactsState {
GtkWidget* stack = nullptr;
GtkWidget* status_label = nullptr;
GtkWidget* list = nullptr;
GtkWidget* search_entry = nullptr;
std::string search_needle;
std::string shown;
bool visible = false;
bool calls_available = false;
bool by_last_name = false;
void (*open_thread)(const std::string&) = nullptr;
void (*start_call)(const std::string&) = nullptr;
};
ContactsState g_contacts;
constexpr int CONTACT_LIMIT = 5000;
void request_contacts() {
nlohmann::json j;
j["command"] = "bt_list_contacts";
j["limit"] = CONTACT_LIMIT;
daemon_send(j);
}
gboolean contact_visible(GtkListBoxRow* row, gpointer) {
if (g_contacts.search_needle.empty())
return TRUE;
const char* haystack = static_cast<const char*>(g_object_get_data(G_OBJECT(row), "search"));
return haystack && std::strstr(haystack, g_contacts.search_needle.c_str()) != nullptr;
}
void on_search_changed(GtkSearchEntry* entry, gpointer) {
g_contacts.search_needle = fold(gtk_entry_get_text(GTK_ENTRY(entry)));
gtk_list_box_invalidate_filter(GTK_LIST_BOX(g_contacts.list));
}
const char* stashed(GtkWidget* widget) {
const char* value = static_cast<const char*>(g_object_get_data(G_OBJECT(widget), "address"));
return value ? value : "";
}
// "name" is spoken, so it carries the address the row shows beside the icon.
GtkWidget* action_button(const char* icon_name,
const std::string& address,
const char* tooltip,
const std::string& name,
GCallback on_click) {
GtkWidget* button = gtk_button_new_from_icon_name(icon_name, GTK_ICON_SIZE_BUTTON);
gtk_button_set_relief(GTK_BUTTON(button), GTK_RELIEF_NONE);
gtk_widget_set_tooltip_text(button, tooltip);
set_accessible_name(button, name);
g_object_set_data_full(G_OBJECT(button), "address", g_strdup(address.c_str()), g_free);
g_signal_connect(button, "clicked", on_click, nullptr);
return button;
}
GtkWidget* build_address_row(const std::string& key) {
const bool is_tel = key.rfind("tel:", 0) == 0;
GtkWidget* box = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 6);
GtkWidget* icon = gtk_image_new_from_icon_name(is_tel ? "call-start-symbolic" : "mail-send-symbolic",
GTK_ICON_SIZE_BUTTON);
gtk_style_context_add_class(gtk_widget_get_style_context(icon), "muted");
gtk_box_pack_start(GTK_BOX(box), icon, FALSE, FALSE, 0);
GtkWidget* label = gtk_label_new(display_address(key).c_str());
gtk_label_set_xalign(GTK_LABEL(label), 0.0);
gtk_label_set_selectable(GTK_LABEL(label), TRUE);
gtk_label_set_ellipsize(GTK_LABEL(label), PANGO_ELLIPSIZE_END);
gtk_label_set_max_width_chars(GTK_LABEL(label), 28);
gtk_box_pack_start(GTK_BOX(box), label, TRUE, TRUE, 0);
gtk_box_pack_end(
GTK_BOX(box),
action_button("edit-copy-symbolic",
display_address(key),
_("Copy"),
// TRANSLATORS: Spoken name of the copy button beside a phone number or email.
tether::tr_format(_("Copy {}"), display_address(key)),
G_CALLBACK(+[](GtkButton* button, gpointer) {
gtk_clipboard_set_text(
gtk_clipboard_get(GDK_SELECTION_CLIPBOARD), stashed(GTK_WIDGET(button)), -1);
set_status_main(_("Copied to the clipboard."));
})),
FALSE,
FALSE,
0);
GtkWidget* message = action_button("mail-message-new-symbolic",
key,
_("Message"),
// TRANSLATORS: Spoken name of the message button beside a phone
// number or email.
tether::tr_format(_("Message {}"), display_address(key)),
G_CALLBACK(+[](GtkButton* button, gpointer) {
if (g_contacts.open_thread)
g_contacts.open_thread(stashed(GTK_WIDGET(button)));
}));
gtk_box_pack_end(GTK_BOX(box), message, FALSE, FALSE, 0);
if (is_tel && g_contacts.calls_available) {
GtkWidget* call = action_button("call-start-symbolic",
display_address(key),
_("Call"),
// TRANSLATORS: Spoken name of the call button beside a phone number.
tether::tr_format(_("Call {}"), display_address(key)),
G_CALLBACK(+[](GtkButton* button, gpointer) {
if (g_contacts.start_call)
g_contacts.start_call(stashed(GTK_WIDGET(button)));
}));
gtk_box_pack_end(GTK_BOX(box), call, FALSE, FALSE, 0);
}
return box;
}
// Lazily built the first time a contact is opened.
void on_expanded(GObject* expander, GParamSpec*, gpointer) {
if (!gtk_expander_get_expanded(GTK_EXPANDER(expander)))
return;
const char* pending = static_cast<const char*>(g_object_get_data(expander, "addresses"));
if (!pending)
return;
GtkWidget* box = gtk_bin_get_child(GTK_BIN(expander));
std::string keys = pending;
size_t start = 0;
while (start <= keys.size()) {
const size_t end = keys.find('\n', start);
const std::string key = keys.substr(start, end - start);
if (!key.empty())
gtk_box_pack_start(GTK_BOX(box), build_address_row(key), FALSE, FALSE, 0);
if (end == std::string::npos)
break;
start = end + 1;
}
g_object_set_data(expander, "addresses", nullptr);
gtk_widget_show_all(box);
}
GtkWidget* build_row(const nlohmann::json& contact) {
const std::string name = contact.value("name", "");
GtkWidget* row = gtk_list_box_row_new();
gtk_list_box_row_set_selectable(GTK_LIST_BOX_ROW(row), FALSE);
gtk_list_box_row_set_activatable(GTK_LIST_BOX_ROW(row), FALSE);
GtkWidget* expander = gtk_expander_new(nullptr);
gtk_container_set_border_width(GTK_CONTAINER(expander), 10);
GtkWidget* title = gtk_label_new(nullptr);
gtk_label_set_xalign(GTK_LABEL(title), 0.0);
gtk_label_set_ellipsize(GTK_LABEL(title), PANGO_ELLIPSIZE_END);
gtk_label_set_max_width_chars(GTK_LABEL(title), 28);
GtkWidget* identity = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 14);
gtk_box_pack_start(GTK_BOX(identity), avatar(name), FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(identity), title, TRUE, TRUE, 0);
if (contact.value("favorite", false)) {
GtkWidget* star = gtk_image_new_from_icon_name("starred-symbolic", GTK_ICON_SIZE_BUTTON);
gtk_widget_set_tooltip_text(star, _("Favorite"));
set_accessible_name(star, _("Favorite"));
gtk_box_pack_start(GTK_BOX(identity), star, FALSE, FALSE, 0);
}
gtk_expander_set_label_widget(GTK_EXPANDER(expander), identity);
GtkWidget* addresses = gtk_box_new(GTK_ORIENTATION_VERTICAL, 4);
gtk_widget_set_margin_top(addresses, 6);
gtk_widget_set_margin_start(addresses, 18);
std::string haystack = name;
std::string first_address;
std::string keys;
if (contact.contains("addresses") && contact["addresses"].is_array()) {
for (const auto& entry : contact["addresses"]) {
if (!entry.is_string())
continue;
const std::string key = entry.get<std::string>();
if (first_address.empty())
first_address = display_address(key);
haystack += " " + display_address(key);
keys += key + "\n";
}
}
set_markup(title, "<b>" + escape_markup(name.empty() ? first_address : name) + "</b>");
g_object_set_data_full(G_OBJECT(row), "search", g_strdup(fold(haystack).c_str()), g_free);
g_object_set_data_full(G_OBJECT(expander), "addresses", g_strdup(keys.c_str()), g_free);
g_signal_connect(expander, "notify::expanded", G_CALLBACK(on_expanded), nullptr);
gtk_container_add(GTK_CONTAINER(expander), addresses);
gtk_container_add(GTK_CONTAINER(row), expander);
return row;
}
void show_contacts(const nlohmann::json& event) {
const std::string payload = event.contains("contacts") ? event["contacts"].dump() : "";
if (payload == g_contacts.shown)
return;
g_contacts.shown = payload;
clear_list_box(g_contacts.list);
const bool empty = !event.contains("contacts") || event["contacts"].empty();
if (!empty) {
for (const auto& contact : event["contacts"])
gtk_list_box_insert(GTK_LIST_BOX(g_contacts.list), build_row(contact), -1);
}
gtk_widget_show_all(g_contacts.list);
gtk_stack_set_visible_child_name(GTK_STACK(g_contacts.stack), empty ? "status" : "list");
}
} // namespace
void contacts_view_set_visible(bool visible) {
g_contacts.visible = visible;
if (!visible)
return;
request_contacts();
gtk_widget_grab_focus(g_contacts.search_entry);
}
void contacts_view_set_sort(bool by_last_name) {
if (by_last_name == g_contacts.by_last_name)
return;
g_contacts.by_last_name = by_last_name;
if (g_contacts.visible)
request_contacts();
}
bool contacts_view_handle_event(const nlohmann::json& event) {
const std::string command = event.value("command", "");
if (command == "bt_contacts")
show_contacts(event);
else if (command == "bt_connection_changed") {
const auto& calls = event.contains("calls") ? event["calls"] : nlohmann::json();
g_contacts.calls_available = calls.is_object() && calls.value("available", false);
}
return false;
}
GtkWidget* contacts_view_new(void (*open_thread)(const std::string& thread_key),
void (*start_call)(const std::string& number)) {
g_contacts.open_thread = open_thread;
g_contacts.start_call = start_call;
g_contacts.stack = gtk_stack_new();
GtkWidget* status_box = gtk_box_new(GTK_ORIENTATION_VERTICAL, 10);
gtk_widget_set_valign(status_box, GTK_ALIGN_CENTER);
style(status_box, "tether-empty");
gtk_widget_set_halign(status_box, GTK_ALIGN_CENTER);
gtk_box_pack_start(GTK_BOX(status_box), navigation_icon("contacts", 56), FALSE, FALSE, 0);
g_contacts.status_label = gtk_label_new(_("No contacts yet. Check the Bluetooth link on the Devices page."));
gtk_label_set_line_wrap(GTK_LABEL(g_contacts.status_label), TRUE);
gtk_label_set_justify(GTK_LABEL(g_contacts.status_label), GTK_JUSTIFY_CENTER);
gtk_style_context_add_class(gtk_widget_get_style_context(g_contacts.status_label), "muted");
gtk_box_pack_start(GTK_BOX(status_box), g_contacts.status_label, FALSE, FALSE, 0);
gtk_stack_add_named(GTK_STACK(g_contacts.stack), status_box, "status");
GtkWidget* list_side = gtk_box_new(GTK_ORIENTATION_VERTICAL, 0);
g_contacts.search_entry = gtk_search_entry_new();
gtk_entry_set_placeholder_text(GTK_ENTRY(g_contacts.search_entry), _("Search contacts"));
set_accessible_name(g_contacts.search_entry, _("Search contacts"));
gtk_widget_set_margin_top(g_contacts.search_entry, 24);
gtk_widget_set_margin_start(g_contacts.search_entry, 24);
gtk_widget_set_margin_end(g_contacts.search_entry, 24);
g_signal_connect(g_contacts.search_entry, "search-changed", G_CALLBACK(on_search_changed), nullptr);
g_signal_connect(g_contacts.search_entry,
"stop-search",
G_CALLBACK(+[](GtkSearchEntry* entry, gpointer) { gtk_entry_set_text(GTK_ENTRY(entry), ""); }),
nullptr);
gtk_box_pack_start(GTK_BOX(list_side), g_contacts.search_entry, FALSE, FALSE, 0);
GtkWidget* scroll = gtk_scrolled_window_new(nullptr, nullptr);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scroll), GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC);
g_contacts.list = gtk_list_box_new();
gtk_style_context_add_class(gtk_widget_get_style_context(g_contacts.list), "tether-feed");
gtk_list_box_set_selection_mode(GTK_LIST_BOX(g_contacts.list), GTK_SELECTION_NONE);
gtk_list_box_set_filter_func(GTK_LIST_BOX(g_contacts.list), contact_visible, nullptr, nullptr);
gtk_container_add(GTK_CONTAINER(scroll), g_contacts.list);
gtk_box_pack_start(GTK_BOX(list_side), scroll, TRUE, TRUE, 0);
gtk_stack_add_named(GTK_STACK(g_contacts.stack), list_side, "list");
gtk_stack_set_visible_child_name(GTK_STACK(g_contacts.stack), "status");
return g_contacts.stack;
}
} // namespace tether::ui