Allow to join group call with enabled/disabled video.

td/generate/scheme/td_api.tl

@@ -4618,8 +4618,9 @@ toggleGroupCallEnabledStartNotification group_call_id:int32 enabled_start_notifi
 //@audio_source Caller audio synchronization source identifier; received from tgcalls
 //@payload Group call join payload; received from tgcalls
 //@is_muted True, if the user's microphone is muted
+//@is_video_enabled True, if the user's video is enabled
 //@invite_hash If non-empty, invite hash to be used to join the group call without being muted by administrators
-joinGroupCall group_call_id:int32 participant_id:MessageSender audio_source:int32 payload:string is_muted:Bool invite_hash:string = Text;
+joinGroupCall group_call_id:int32 participant_id:MessageSender audio_source:int32 payload:string is_muted:Bool is_video_enabled:Bool invite_hash:string = Text;
 
 //@description Starts screen sharing in a joined group call. Returns join response payload for tgcalls @group_call_id Group call identifier @payload Group call join payload; received from tgcalls
 startGroupCallScreenSharing group_call_id:int32 payload:string = Text;

td/telegram/GroupCallManager.cpp

@@ -359,7 +359,7 @@ class JoinGroupCallQuery : public Td::ResultHandler {
   }
 
   NetQueryRef send(InputGroupCallId input_group_call_id, DialogId as_dialog_id, const string &payload, bool is_muted,
-                   const string &invite_hash, uint64 generation) {
+                   bool is_video_muted, const string &invite_hash, uint64 generation) {
     input_group_call_id_ = input_group_call_id;
     as_dialog_id_ = as_dialog_id;
     generation_ = generation;
@@ -379,6 +379,9 @@ class JoinGroupCallQuery : public Td::ResultHandler {
     if (!invite_hash.empty()) {
       flags |= telegram_api::phone_joinGroupCall::INVITE_HASH_MASK;
     }
+    if (is_video_muted) {
+      flags |= telegram_api::phone_joinGroupCall::VIDEO_MUTED_MASK;
+    }
     auto query = G()->net_query_creator().create(telegram_api::phone_joinGroupCall(
         flags, false /*ignored*/, false /*ignored*/, input_group_call_id.get_input_group_call(),
         std::move(join_as_input_peer), invite_hash, make_tl_object<telegram_api::dataJSON>(payload)));
@@ -2362,8 +2365,8 @@ void GroupCallManager::start_scheduled_group_call(GroupCallId group_call_id, Pro
 }
 
 void GroupCallManager::join_group_call(GroupCallId group_call_id, DialogId as_dialog_id, int32 audio_source,
-                                       string &&payload, bool is_muted, const string &invite_hash,
+                                       string &&payload, bool is_muted, bool is_video_enabled,
-                                       Promise<string> &&promise) {
+                                       const string &invite_hash, Promise<string> &&promise) {
   TRY_RESULT_PROMISE(promise, input_group_call_id, get_input_group_call_id(group_call_id));
 
   auto *group_call = get_group_call(input_group_call_id);
@@ -2426,8 +2429,9 @@ void GroupCallManager::join_group_call(GroupCallId group_call_id, DialogId as_di
         send_closure(actor_id, &GroupCallManager::finish_join_group_call, input_group_call_id, generation,
                      result.move_as_error());
       });
-  request->query_ref = td_->create_handler<JoinGroupCallQuery>(std::move(query_promise))
+  request->query_ref =
-                           ->send(input_group_call_id, as_dialog_id, payload, is_muted, invite_hash, generation);
+      td_->create_handler<JoinGroupCallQuery>(std::move(query_promise))
+          ->send(input_group_call_id, as_dialog_id, payload, is_muted, !is_video_enabled, invite_hash, generation);
 
   if (group_call->dialog_id.is_valid()) {
     td_->messages_manager_->on_update_dialog_default_join_group_call_as_dialog_id(group_call->dialog_id, as_dialog_id,
@@ -2448,6 +2452,7 @@ void GroupCallManager::join_group_call(GroupCallId group_call_id, DialogId as_di
     // it contains reasonable default "!call.mute_new_participants || call.can_be_managed"
     participant.server_is_muted_by_admin = !group_call->can_self_unmute && !can_manage_group_call(input_group_call_id);
     participant.server_is_muted_by_themselves = is_muted && !participant.server_is_muted_by_admin;
+    participant.server_is_video_muted = !is_video_enabled || participant.server_is_muted_by_admin;
     participant.is_just_joined = !is_rejoin;
     participant.is_fake = true;
     int diff = process_group_call_participant(input_group_call_id, std::move(participant));
@@ -2518,9 +2523,8 @@ void GroupCallManager::end_group_call_screen_sharing(GroupCallId group_call_id,
   }
   if (!group_call->is_joined || group_call->is_being_left) {
     if (is_group_call_being_joined(input_group_call_id) || group_call->need_rejoin) {
-      group_call->after_join.push_back(
+      group_call->after_join.push_back(PromiseCreator::lambda(
-          PromiseCreator::lambda([actor_id = actor_id(this), group_call_id,
+          [actor_id = actor_id(this), group_call_id, promise = std::move(promise)](Result<Unit> &&result) mutable {
-                                  promise = std::move(promise)](Result<Unit> &&result) mutable {
             if (result.is_error()) {
               promise.set_error(Status::Error(400, "GROUPCALL_JOIN_MISSING"));
             } else {

td/telegram/GroupCallManager.h

@@ -65,7 +65,7 @@ class GroupCallManager : public Actor {
   void start_scheduled_group_call(GroupCallId group_call_id, Promise<Unit> &&promise);
 
   void join_group_call(GroupCallId group_call_id, DialogId as_dialog_id, int32 audio_source, string &&payload,
-                       bool is_muted, const string &invite_hash, Promise<string> &&promise);
+                       bool is_muted, bool is_video_enabled, const string &invite_hash, Promise<string> &&promise);
 
   void start_group_call_screen_sharing(GroupCallId group_call_id, string &&payload, Promise<string> &&promise);
 

td/telegram/GroupCallParticipant.h

@@ -33,6 +33,7 @@ struct GroupCallParticipant {
   bool server_is_muted_by_themselves = false;
   bool server_is_muted_by_admin = false;
   bool server_is_muted_locally = false;
+  bool server_is_video_muted = false;
   bool is_self = false;
 
   bool can_be_muted_for_all_users = false;

td/telegram/Td.cpp

@@ -6032,7 +6032,7 @@ void Td::on_request(uint64 id, td_api::joinGroupCall &request) {
   group_call_manager_->join_group_call(GroupCallId(request.group_call_id_),
                                        group_call_manager_->get_group_call_participant_id(request.participant_id_),
                                        request.audio_source_, std::move(request.payload_), request.is_muted_,
-                                       request.invite_hash_, std::move(query_promise));
+                                       request.is_video_enabled_, request.invite_hash_, std::move(query_promise));
 }
 
 void Td::on_request(uint64 id, td_api::startGroupCallScreenSharing &request) {
@@ -6053,8 +6053,7 @@ void Td::on_request(uint64 id, td_api::startGroupCallScreenSharing &request) {
 void Td::on_request(uint64 id, const td_api::endGroupCallScreenSharing &request) {
   CHECK_IS_USER();
   CREATE_OK_REQUEST_PROMISE();
-  group_call_manager_->end_group_call_screen_sharing(GroupCallId(request.group_call_id_),
+  group_call_manager_->end_group_call_screen_sharing(GroupCallId(request.group_call_id_), std::move(promise));
-                                                       std::move(promise));
 }
 
 void Td::on_request(uint64 id, td_api::setGroupCallTitle &request) {

td/telegram/cli.cpp

@@ -2717,7 +2717,7 @@ class CliClient final : public Actor {
       } else {
         send_request(td_api::make_object<td_api::joinGroupCall>(as_group_call_id(group_call_id),
                                                                 as_message_sender(participant_id), group_call_source_,
-                                                                std::move(payload), true, invite_hash));
+                                                                std::move(payload), true, false, invite_hash));
       }
     } else if (op == "egcss") {
       string group_call_id = args;