tdlight-team/tdlight
tdlight-team/tdlight
1
1
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Add updateHavePendingNotifications.

Browse Source 
GitOrigin-RevId: 762b32f5a5d271f82c3f1c03efff92d8ccb7321d
This commit is contained in:
levlam 2018-12-24 19:45:19 +03:00
parent bbcad65737
commit fe8cf6cd3d
4 changed files with 43 additions and 3 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
td/generate/scheme/td_api.tl
View File

@ -2271,6 +2271,9 @@ updateNotificationGroup notification_group_id:int32 type:NotificationGroupType c
//@description Contains active notifications that was shown on previous application launches. This update is sent only if a message database is used. In that case it comes once before any updateNotification and updateNotificationGroup update @groups Lists of active notification groups
updateActiveNotifications groups:vector<notificationGroup> = Update;
//@description Describes, whether there are some pending notification updates. Can be used to prevent application from killing, while there are some pending notifiations @have_pending_notifications True, if there are some pending notification updates, which will be sent soon
updateHavePendingNotifications have_pending_notifications:Bool = Update;
//@description Some messages were deleted @chat_id Chat identifier @message_ids Identifiers of the deleted messages
//@is_permanent True, if the messages are permanently deleted by a user (as opposed to just becoming unaccessible)
//@from_cache True, if the messages are deleted only from the cache and can possibly be retrieved again in the future

BIN
td/generate/scheme/td_api.tlo
View File

Binary file not shown.

39
td/telegram/NotificationManager.cpp
View File

@ -525,7 +525,9 @@ void NotificationManager::try_reuse_notification_group_id(NotificationGroupId gr
flush_pending_notifications_timeout_.cancel_timeout(group_id.get());
flush_pending_updates_timeout_.cancel_timeout(group_id.get());
pending_updates_.erase(group_id.get());
if (pending_updates_.erase(group_id.get()) == 1) {
on_pending_notification_update_count_changed(-1);
}
}
current_notification_group_id_ = NotificationGroupId(current_notification_group_id_.get() - 1);
@ -625,6 +627,9 @@ void NotificationManager::add_notification(NotificationGroupId group_id, Notific
group.pending_notifications_flush_time = flush_time;
flush_pending_notifications_timeout_.set_timeout_at(group_id.get(), group.pending_notifications_flush_time);
}
if (group.pending_notifications.empty()) {
on_pending_notification_update_count_changed(1);
}
group.pending_notifications.push_back(std::move(notification));
}
@ -671,7 +676,11 @@ NotificationUpdate as_notification_update(const td_api::Update *update) {
void NotificationManager::add_update(int32 group_id, td_api::object_ptr<td_api::Update> update) {
VLOG(notifications) << "Add " << as_notification_update(update.get());
pending_updates_[group_id].push_back(std::move(update));
auto &updates = pending_updates_[group_id];
if (updates.empty()) {
on_pending_notification_update_count_changed(1);
}
updates.push_back(std::move(update));
if (!running_get_difference_ && running_get_chat_difference_.count(group_id) == 0) {
flush_pending_updates_timeout_.add_timeout_in(group_id, MIN_UPDATE_DELAY_MS * 1e-3);
} else {
@ -1023,13 +1032,14 @@ void NotificationManager::flush_pending_updates(int32 group_id, const char *sour
VLOG(notifications) << "Send " << as_notification_update(update.get());
send_closure(G()->td(), &Td::send_update, std::move(update));
}
on_pending_notification_update_count_changed(-1);
}
void NotificationManager::flush_all_pending_updates(bool include_delayed_chats, const char *source) {
VLOG(notifications) << "Flush all pending notification updates "
<< (include_delayed_chats ? "with delayed chats " : "") << "from " << source;
vector<NotificationGroupKey> ready_group_keys;
for (auto &it : pending_updates_) {
for (const auto &it : pending_updates_) {
if (include_delayed_chats || running_get_chat_difference_.count(it.first) == 0) {
auto group_it = get_group(NotificationGroupId(it.first));
CHECK(group_it != groups_.end());
@ -1218,6 +1228,7 @@ void NotificationManager::flush_pending_notifications(NotificationGroupId group_
group.pending_notifications_flush_time = 0;
group.pending_notifications.clear();
on_pending_notification_update_count_changed(-1);
// if we can delete a lot of notifications simultaneously
if (group.notifications.size() > keep_notification_group_size_ + EXTRA_GROUP_SIZE &&
group.type != NotificationGroupType::Calls) {
@ -1423,6 +1434,7 @@ void NotificationManager::remove_notification(NotificationGroupId group_id, Noti
if (group_it->second.pending_notifications.empty()) {
group_it->second.pending_notifications_flush_time = 0;
flush_pending_notifications_timeout_.cancel_timeout(group_id.get());
on_pending_notification_update_count_changed(-1);
}
return promise.set_value(Unit());
}
@ -1524,6 +1536,7 @@ void NotificationManager::remove_notification_group(NotificationGroupId group_id
if (group_it->second.pending_notifications.empty()) {
group_it->second.pending_notifications_flush_time = 0;
flush_pending_notifications_timeout_.cancel_timeout(group_id.get());
on_pending_notification_update_count_changed(-1);
}
if (new_total_count != -1) {
new_total_count -= static_cast<int32>(group_it->second.pending_notifications.size());
@ -1893,6 +1906,7 @@ void NotificationManager::before_get_difference() {
}
running_get_difference_ = true;
on_pending_notification_update_count_changed(1);
}
void NotificationManager::after_get_difference() {
@ -1902,6 +1916,7 @@ void NotificationManager::after_get_difference() {
CHECK(running_get_difference_);
running_get_difference_ = false;
on_pending_notification_update_count_changed(-1);
flush_pending_notifications_timeout_.set_timeout_in(0, MIN_NOTIFICATION_DELAY_MS * 1e-3);
}
@ -1922,6 +1937,7 @@ void NotificationManager::before_get_chat_difference(NotificationGroupId group_i
VLOG(notifications) << "Before get chat difference in " << group_id;
CHECK(group_id.is_valid());
running_get_chat_difference_.insert(group_id.get());
on_pending_notification_update_count_changed(1);
}
void NotificationManager::after_get_chat_difference(NotificationGroupId group_id) {
@ -1934,6 +1950,7 @@ void NotificationManager::after_get_chat_difference(NotificationGroupId group_id
auto erased_count = running_get_chat_difference_.erase(group_id.get());
if (erased_count == 1) {
flush_pending_notifications_timeout_.set_timeout_in(-group_id.get(), MIN_NOTIFICATION_DELAY_MS * 1e-3);
on_pending_notification_update_count_changed(-1);
}
}
@ -1964,6 +1981,7 @@ void NotificationManager::get_current_state(vector<td_api::object_ptr<td_api::Up
void NotificationManager::flush_all_notifications() {
flush_all_pending_notifications();
flush_all_pending_updates(true, "flush_all_notifications");
CHECK(pending_notification_update_count_ == 0);
}
void NotificationManager::destroy_all_notifications() {
@ -1985,7 +2003,22 @@ void NotificationManager::destroy_all_notifications() {
}
flush_all_pending_updates(true, "destroy_all_notifications");
if (pending_notification_update_count_ != 0) {
on_pending_notification_update_count_changed(-pending_notification_update_count_);
}
is_destroyed_ = true;
}
void NotificationManager::on_pending_notification_update_count_changed(int32 diff) {
bool had_pending = pending_notification_update_count_ != 0;
pending_notification_update_count_ += diff;
CHECK(pending_notification_update_count_ >= 0);
bool have_pending = pending_notification_update_count_ != 0;
if (had_pending != have_pending && !is_destroyed_) {
auto update = td_api::make_object<td_api::updateHavePendingNotifications>(have_pending);
VLOG(notifications) << "Send " << oneline(to_string(update));
send_closure(G()->td(), &Td::send_update, std::move(update));
}
}
} // namespace td

4
td/telegram/NotificationManager.h
View File

@ -218,6 +218,8 @@ class NotificationManager : public Actor {
void after_get_chat_difference_impl(NotificationGroupId group_id);
void on_pending_notification_update_count_changed(int32 diff);
NotificationId current_notification_id_;
NotificationGroupId current_notification_group_id_;
@ -229,6 +231,8 @@ class NotificationManager : public Actor {
int32 notification_cloud_delay_ms_ = DEFAULT_ONLINE_CLOUD_DELAY_MS;
int32 notification_default_delay_ms_ = DEFAULT_DEFAULT_DELAY_MS;
int32 pending_notification_update_count_ = 0;
NotificationGroupKey last_loaded_notification_group_key_;
bool is_destroyed_ = false;