diff --git a/submodules/DeviceLocationManager/Sources/DeviceLocationManager.swift b/submodules/DeviceLocationManager/Sources/DeviceLocationManager.swift
index b4b052d256..beacf3f56b 100644
--- a/submodules/DeviceLocationManager/Sources/DeviceLocationManager.swift
+++ b/submodules/DeviceLocationManager/Sources/DeviceLocationManager.swift
@@ -9,9 +9,9 @@ public enum DeviceLocationMode: Int32 {
 private final class DeviceLocationSubscriber {
     let id: Int32
     let mode: DeviceLocationMode
-    let update: (CLLocationCoordinate2D) -> Void
+    let update: (CLLocationCoordinate2D, Double, Double?) -> Void
     
-    init(id: Int32, mode: DeviceLocationMode, update: @escaping (CLLocationCoordinate2D) -> Void) {
+    init(id: Int32, mode: DeviceLocationMode, update: @escaping (CLLocationCoordinate2D, Double, Double?) -> Void) {
         self.id = id
         self.mode = mode
         self.update = update
@@ -39,7 +39,8 @@ public final class DeviceLocationManager: NSObject {
     private var subscribers: [DeviceLocationSubscriber] = []
     private var currentTopMode: DeviceLocationMode?
     
-    private var currentLocation: CLLocationCoordinate2D?
+    private var currentLocation: (CLLocationCoordinate2D, Double)?
+    private var currentHeading: CLHeading?
     
     public init(queue: Queue, log: ((String) -> Void)? = nil) {
         assert(queue.isCurrent())
@@ -60,7 +61,7 @@ public final class DeviceLocationManager: NSObject {
         self.manager.pausesLocationUpdatesAutomatically = false
     }
     
-    public func push(mode: DeviceLocationMode, updated: @escaping (CLLocationCoordinate2D) -> Void) -> Disposable {
+    public func push(mode: DeviceLocationMode, updated: @escaping (CLLocationCoordinate2D, Double, Double?) -> Void) -> Disposable {
         assert(self.queue.isCurrent())
         
         let id = self.nextSubscriberId
@@ -68,7 +69,7 @@ public final class DeviceLocationManager: NSObject {
         self.subscribers.append(DeviceLocationSubscriber(id: id, mode: mode, update: updated))
         
         if let currentLocation = self.currentLocation {
-            updated(currentLocation)
+            updated(currentLocation.0, currentLocation.1, self.currentHeading?.magneticHeading)
         }
         
         self.updateTopMode()
@@ -107,6 +108,7 @@ public final class DeviceLocationManager: NSObject {
                         self.manager.requestAlwaysAuthorization()
                     }
                     self.manager.startUpdatingLocation()
+                    self.manager.startUpdatingHeading()
                 }
             } else {
                 self.currentLocation = nil
@@ -123,9 +125,22 @@ extension DeviceLocationManager: CLLocationManagerDelegate {
         
         if let location = locations.first {
             if self.currentTopMode != nil {
-                self.currentLocation = location.coordinate
+                self.currentLocation = (location.coordinate, location.horizontalAccuracy)
                 for subscriber in self.subscribers {
-                    subscriber.update(location.coordinate)
+                    subscriber.update(location.coordinate, location.horizontalAccuracy, self.currentHeading?.magneticHeading)
+                }
+            }
+        }
+    }
+    
+    public func locationManager(_ manager: CLLocationManager, didUpdateHeading newHeading: CLHeading) {
+        assert(self.queue.isCurrent())
+        
+        if self.currentTopMode != nil {
+            self.currentHeading = newHeading
+            if let currentLocation = self.currentLocation {
+                for subscriber in self.subscribers {
+                    subscriber.update(currentLocation.0, currentLocation.1, newHeading.magneticHeading)
                 }
             }
         }
@@ -135,7 +150,7 @@ extension DeviceLocationManager: CLLocationManagerDelegate {
 public func currentLocationManagerCoordinate(manager: DeviceLocationManager, timeout timeoutValue: Double) -> Signal<CLLocationCoordinate2D?, NoError> {
     return (
         Signal { subscriber in
-            let disposable = manager.push(mode: .precise, updated: { coordinate in
+            let disposable = manager.push(mode: .precise, updated: { coordinate, _, _ in
                 subscriber.putNext(coordinate)
                 subscriber.putCompletion()
             })
diff --git a/submodules/InstantPageUI/Sources/InstantPageLayout.swift b/submodules/InstantPageUI/Sources/InstantPageLayout.swift
index 4de40ca9b9..d1d5c4bd8d 100644
--- a/submodules/InstantPageUI/Sources/InstantPageLayout.swift
+++ b/submodules/InstantPageUI/Sources/InstantPageLayout.swift
@@ -816,7 +816,7 @@ func layoutInstantPageBlock(webpage: TelegramMediaWebpage, rtl: Bool, block: Ins
                 }
             }
             
-            let map = TelegramMediaMap(latitude: latitude, longitude: longitude, geoPlace: nil, venue: nil, liveBroadcastingTimeout: nil)
+            let map = TelegramMediaMap(latitude: latitude, longitude: longitude, heading: nil, accuracyRadius: nil, geoPlace: nil, venue: nil, liveBroadcastingTimeout: nil)
             let attributes: [InstantPageImageAttribute] = [InstantPageMapAttribute(zoom: zoom, dimensions: dimensions.cgSize)]
             
             var contentSize = CGSize(width: boundingWidth - safeInset * 2.0, height: 0.0)
diff --git a/submodules/LegacyDataImport/Sources/LegacyChatImport.swift b/submodules/LegacyDataImport/Sources/LegacyChatImport.swift
index 3280e88720..c1c77fd37f 100644
--- a/submodules/LegacyDataImport/Sources/LegacyChatImport.swift
+++ b/submodules/LegacyDataImport/Sources/LegacyChatImport.swift
@@ -553,7 +553,7 @@ private func loadLegacyMessages(account: TemporaryAccount, basePath: String, acc
                         if let v = item.venue {
                             venue = MapVenue(title: v.title ?? "", address: v.address ?? "", provider: v.provider == "" ? nil : v.provider, id: v.venueId == "" ? nil : v.venueId, type: v.type == "" ? nil : v.type)
                         }
-                        parsedMedia.append(TelegramMediaMap(latitude: item.latitude, longitude: item.longitude, geoPlace: nil, venue: venue, liveBroadcastingTimeout: nil))
+                        parsedMedia.append(TelegramMediaMap(latitude: item.latitude, longitude: item.longitude, heading: nil, accuracyRadius: nil, geoPlace: nil, venue: venue, liveBroadcastingTimeout: nil))
                     }
                 }
             }
diff --git a/submodules/LiveLocationManager/Sources/LiveLocationManager.swift b/submodules/LiveLocationManager/Sources/LiveLocationManager.swift
index 4c31f5589d..ca36297c12 100644
--- a/submodules/LiveLocationManager/Sources/LiveLocationManager.swift
+++ b/submodules/LiveLocationManager/Sources/LiveLocationManager.swift
@@ -107,9 +107,9 @@ public final class LiveLocationManagerImpl: LiveLocationManager {
             if let strongSelf = self {
                 if value {
                     let queue = strongSelf.queue
-                    strongSelf.deviceLocationDisposable.set(strongSelf.locationManager.push(mode: .precise, updated: { coordinate in
+                    strongSelf.deviceLocationDisposable.set(strongSelf.locationManager.push(mode: .precise, updated: { coordinate, accuracyRadius, heading in
                         queue.async {
-                            self?.updateDeviceCoordinate(coordinate)
+                            self?.updateDeviceCoordinate(coordinate, accuracyRadius: accuracyRadius, heading: heading)
                         }
                     }))
                 } else {
@@ -158,7 +158,7 @@ public final class LiveLocationManagerImpl: LiveLocationManager {
         let addedStopped = stopMessageIds.subtracting(self.stopMessageIds)
         self.stopMessageIds = stopMessageIds
         for id in addedStopped {
-            self.editMessageDisposables.set((requestEditLiveLocation(postbox: self.postbox, network: self.network, stateManager: self.stateManager, messageId: id, coordinate: nil)
+            self.editMessageDisposables.set((requestEditLiveLocation(postbox: self.postbox, network: self.network, stateManager: self.stateManager, messageId: id, coordinate: nil, heading: nil)
                 |> deliverOn(self.queue)).start(completed: { [weak self] in
                     if let strongSelf = self {
                         strongSelf.editMessageDisposables.set(nil, forKey: id)
@@ -207,13 +207,13 @@ public final class LiveLocationManagerImpl: LiveLocationManager {
         self.update(broadcastToMessageIds: updatedBroadcastToMessageIds, stopMessageIds: updatedStopMessageIds)
     }
     
-    private func updateDeviceCoordinate(_ coordinate: CLLocationCoordinate2D) {
+    private func updateDeviceCoordinate(_ coordinate: CLLocationCoordinate2D, accuracyRadius: Double, heading: Double?) {
         assert(self.queue.isCurrent())
         
         let ids = self.broadcastToMessageIds
         let remainingIds = Atomic<Set<MessageId>>(value: Set(ids.keys))
         for id in ids.keys {
-            self.editMessageDisposables.set((requestEditLiveLocation(postbox: self.postbox, network: self.network, stateManager: self.stateManager, messageId: id, coordinate: (latitude: coordinate.latitude, longitude: coordinate.longitude))
+            self.editMessageDisposables.set((requestEditLiveLocation(postbox: self.postbox, network: self.network, stateManager: self.stateManager, messageId: id, coordinate: (latitude: coordinate.latitude, longitude: coordinate.longitude, accuracyRadius: Int32(accuracyRadius)), heading: Int32(heading ?? 0))
             |> deliverOn(self.queue)).start(completed: { [weak self] in
                 if let strongSelf = self {
                     strongSelf.editMessageDisposables.set(nil, forKey: id)
@@ -247,7 +247,7 @@ public final class LiveLocationManagerImpl: LiveLocationManager {
                         let timestamp = Int32(CFAbsoluteTimeGetCurrent() + kCFAbsoluteTimeIntervalSince1970)
                         for i in 0 ..< updatedMedia.count {
                             if let media = updatedMedia[i] as? TelegramMediaMap, let _ = media.liveBroadcastingTimeout {
-                                updatedMedia[i] = TelegramMediaMap(latitude: media.latitude, longitude: media.longitude, geoPlace: media.geoPlace, venue: media.venue, liveBroadcastingTimeout: max(0, timestamp - currentMessage.timestamp - 1))
+                                updatedMedia[i] = TelegramMediaMap(latitude: media.latitude, longitude: media.longitude, heading: media.heading, accuracyRadius: media.accuracyRadius, geoPlace: media.geoPlace, venue: media.venue, liveBroadcastingTimeout: max(0, timestamp - currentMessage.timestamp - 1))
                             }
                         }
                         return .update(StoreMessage(id: currentMessage.id, globallyUniqueId: currentMessage.globallyUniqueId, groupingKey: currentMessage.groupingKey, threadId: currentMessage.threadId, timestamp: currentMessage.timestamp, flags: StoreMessageFlags(currentMessage.flags), tags: currentMessage.tags, globalTags: currentMessage.globalTags, localTags: currentMessage.localTags, forwardInfo: storeForwardInfo, authorId: currentMessage.author?.id, text: currentMessage.text, attributes: currentMessage.attributes, media: updatedMedia))
diff --git a/submodules/LocationUI/Sources/LegacyLocationController.swift b/submodules/LocationUI/Sources/LegacyLocationController.swift
index 473b1f5708..3ad6687a3a 100644
--- a/submodules/LocationUI/Sources/LegacyLocationController.swift
+++ b/submodules/LocationUI/Sources/LegacyLocationController.swift
@@ -120,7 +120,7 @@ private func telegramMap(for location: TGLocationMediaAttachment) -> TelegramMed
     } else {
         mapVenue = nil
     }
-    return TelegramMediaMap(latitude: location.latitude, longitude: location.longitude, geoPlace: nil, venue: mapVenue, liveBroadcastingTimeout: nil)
+    return TelegramMediaMap(latitude: location.latitude, longitude: location.longitude, heading: nil, accuracyRadius: nil, geoPlace: nil, venue: mapVenue, liveBroadcastingTimeout: nil)
 }
 
 func legacyLocationPalette(from theme: PresentationTheme) -> TGLocationPallete {
diff --git a/submodules/LocationUI/Sources/LocationPickerController.swift b/submodules/LocationUI/Sources/LocationPickerController.swift
index 3602c194f3..3b0c7fb075 100644
--- a/submodules/LocationUI/Sources/LocationPickerController.swift
+++ b/submodules/LocationUI/Sources/LocationPickerController.swift
@@ -103,7 +103,7 @@ public final class LocationPickerController: ViewController {
         })
         
         let locationWithTimeout: (CLLocationCoordinate2D, Int32?) -> TelegramMediaMap = { coordinate, timeout in
-            return TelegramMediaMap(latitude: coordinate.latitude, longitude: coordinate.longitude, geoPlace: nil, venue: nil, liveBroadcastingTimeout: timeout)
+            return TelegramMediaMap(latitude: coordinate.latitude, longitude: coordinate.longitude, heading: nil, accuracyRadius: nil, geoPlace: nil, venue: nil, liveBroadcastingTimeout: timeout)
         }
                 
         self.interaction = LocationPickerInteraction(sendLocation: { [weak self] coordinate in
@@ -168,7 +168,7 @@ public final class LocationPickerController: ViewController {
             }
             let venueType = venue.venue?.type ?? ""
             if ["home", "work"].contains(venueType) {
-                completion(TelegramMediaMap(latitude: venue.latitude, longitude: venue.longitude, geoPlace: nil, venue: nil, liveBroadcastingTimeout: nil), nil)
+                completion(TelegramMediaMap(latitude: venue.latitude, longitude: venue.longitude, heading: nil, accuracyRadius: nil, geoPlace: nil, venue: nil, liveBroadcastingTimeout: nil), nil)
             } else {
                 completion(venue, nil)
             }
diff --git a/submodules/LocationUI/Sources/LocationPickerControllerNode.swift b/submodules/LocationUI/Sources/LocationPickerControllerNode.swift
index 78e0adcad2..0e61831c9c 100644
--- a/submodules/LocationUI/Sources/LocationPickerControllerNode.swift
+++ b/submodules/LocationUI/Sources/LocationPickerControllerNode.swift
@@ -386,10 +386,10 @@ final class LocationPickerControllerNode: ViewControllerTracingNode, CLLocationM
                     |> map { homeCoordinate, workCoordinate -> [TelegramMediaMap]? in
                         var venues: [TelegramMediaMap] = []
                         if let (latitude, longitude) = homeCoordinate, let address = homeAddress {
-                            venues.append(TelegramMediaMap(latitude: latitude, longitude: longitude, geoPlace: nil, venue: MapVenue(title: presentationData.strings.Map_Home, address: address.displayString, provider: nil, id: "home", type: "home"), liveBroadcastingTimeout: nil))
+                            venues.append(TelegramMediaMap(latitude: latitude, longitude: longitude, heading: nil, accuracyRadius: nil, geoPlace: nil, venue: MapVenue(title: presentationData.strings.Map_Home, address: address.displayString, provider: nil, id: "home", type: "home"), liveBroadcastingTimeout: nil))
                         }
                         if let (latitude, longitude) = workCoordinate, let address = workAddress {
-                            venues.append(TelegramMediaMap(latitude: latitude, longitude: longitude, geoPlace: nil, venue: MapVenue(title: presentationData.strings.Map_Work, address: address.displayString, provider: nil, id: "work", type: "work"), liveBroadcastingTimeout: nil))
+                            venues.append(TelegramMediaMap(latitude: latitude, longitude: longitude, heading: nil, accuracyRadius: nil, geoPlace: nil, venue: MapVenue(title: presentationData.strings.Map_Work, address: address.displayString, provider: nil, id: "work", type: "work"), liveBroadcastingTimeout: nil))
                         }
                         return venues
                     }
diff --git a/submodules/LocationUI/Sources/LocationSearchContainerNode.swift b/submodules/LocationUI/Sources/LocationSearchContainerNode.swift
index aaac3717f6..c66026b5dd 100644
--- a/submodules/LocationUI/Sources/LocationSearchContainerNode.swift
+++ b/submodules/LocationUI/Sources/LocationSearchContainerNode.swift
@@ -179,7 +179,7 @@ final class LocationSearchContainerNode: ASDisplayNode {
                             guard let placemarkLocation = placemark.location else {
                                 continue
                             }
-                            let location = TelegramMediaMap(latitude: placemarkLocation.coordinate.latitude, longitude: placemarkLocation.coordinate.longitude, geoPlace: nil, venue: nil, liveBroadcastingTimeout: nil)
+                            let location = TelegramMediaMap(latitude: placemarkLocation.coordinate.latitude, longitude: placemarkLocation.coordinate.longitude, heading: nil, accuracyRadius: nil, geoPlace: nil, venue: nil, liveBroadcastingTimeout: nil)
                             
                             entries.append(LocationSearchEntry(index: index, theme: themeAndStrings.0, location: location, title: placemark.name ?? "Name", distance: placemarkLocation.distance(from: currentLocation)))
                             
diff --git a/submodules/LocationUI/Sources/LocationUtils.swift b/submodules/LocationUI/Sources/LocationUtils.swift
index 901d96af3c..f8d5f0b8bc 100644
--- a/submodules/LocationUI/Sources/LocationUtils.swift
+++ b/submodules/LocationUI/Sources/LocationUtils.swift
@@ -8,7 +8,7 @@ import MapKit
 
 extension TelegramMediaMap {
     convenience init(coordinate: CLLocationCoordinate2D, liveBroadcastingTimeout: Int32? = nil) {
-        self.init(latitude: coordinate.latitude, longitude: coordinate.longitude, geoPlace: nil, venue: nil, liveBroadcastingTimeout: liveBroadcastingTimeout)
+        self.init(latitude: coordinate.latitude, longitude: coordinate.longitude, heading: nil, accuracyRadius: nil, geoPlace: nil, venue: nil, liveBroadcastingTimeout: liveBroadcastingTimeout)
     }
     
     var coordinate: CLLocationCoordinate2D {
diff --git a/submodules/PeerInfoUI/Sources/GroupInfoController.swift b/submodules/PeerInfoUI/Sources/GroupInfoController.swift
index d93f87178e..8e74a94b0c 100644
--- a/submodules/PeerInfoUI/Sources/GroupInfoController.swift
+++ b/submodules/PeerInfoUI/Sources/GroupInfoController.swift
@@ -2112,7 +2112,7 @@ public func groupInfoController(context: AccountContext, peerId originalPeerId:
                 return
             }
             let presentationData = context.sharedContext.currentPresentationData.with { $0 }
-            let mapMedia = TelegramMediaMap(latitude: location.latitude, longitude: location.longitude, geoPlace: nil, venue: MapVenue(title: peer.displayTitle(strings: presentationData.strings, displayOrder: presentationData.nameDisplayOrder), address: location.address, provider: nil, id: nil, type: nil), liveBroadcastingTimeout: nil)
+            let mapMedia = TelegramMediaMap(latitude: location.latitude, longitude: location.longitude, heading: nil, accuracyRadius: nil, geoPlace: nil, venue: MapVenue(title: peer.displayTitle(strings: presentationData.strings, displayOrder: presentationData.nameDisplayOrder), address: location.address, provider: nil, id: nil, type: nil), liveBroadcastingTimeout: nil)
             let controller = legacyLocationController(message: nil, mapMedia: mapMedia, context: context, openPeer: { _ in }, sendLiveLocation: { _, _ in }, stopLiveLocation: {}, openUrl: { url in
                 context.sharedContext.applicationBindings.openUrl(url)
             })
diff --git a/submodules/SettingsUI/Sources/Themes/ThemeAutoNightSettingsController.swift b/submodules/SettingsUI/Sources/Themes/ThemeAutoNightSettingsController.swift
index 70501d7344..2f5fe0fe67 100644
--- a/submodules/SettingsUI/Sources/Themes/ThemeAutoNightSettingsController.swift
+++ b/submodules/SettingsUI/Sources/Themes/ThemeAutoNightSettingsController.swift
@@ -385,7 +385,7 @@ public func themeAutoNightSettingsController(context: AccountContext) -> ViewCon
     
     let forceUpdateLocation: () -> Void = {
         let locationCoordinates = Signal<(Double, Double), NoError> { subscriber in
-            return context.sharedContext.locationManager!.push(mode: DeviceLocationMode.precise, updated: { coordinate in
+            return context.sharedContext.locationManager!.push(mode: DeviceLocationMode.precise, updated: { coordinate, _, _ in
                 subscriber.putNext((coordinate.latitude, coordinate.longitude))
                 subscriber.putCompletion()
             })
diff --git a/submodules/ShareItems/Sources/ShareItems.swift b/submodules/ShareItems/Sources/ShareItems.swift
index 642dc3feb3..4d450af59b 100644
--- a/submodules/ShareItems/Sources/ShareItems.swift
+++ b/submodules/ShareItems/Sources/ShareItems.swift
@@ -260,9 +260,9 @@ private func preparedShareItem(account: Account, to peerId: PeerId, value: [Stri
                 let disposable = TGShareLocationSignals.locationMessageContent(for: url).start(next: { value in
                     if let value = value as? TGShareLocationResult {
                         if let title = value.title {
-                            subscriber.putNext(.done(.media(.media(.standalone(media: TelegramMediaMap(latitude: value.latitude, longitude: value.longitude, geoPlace: nil, venue: MapVenue(title: title, address: value.address, provider: value.provider, id: value.venueId, type: value.venueType), liveBroadcastingTimeout: nil))))))
+                            subscriber.putNext(.done(.media(.media(.standalone(media: TelegramMediaMap(latitude: value.latitude, longitude: value.longitude, heading: nil, accuracyRadius: nil, geoPlace: nil, venue: MapVenue(title: title, address: value.address, provider: value.provider, id: value.venueId, type: value.venueType), liveBroadcastingTimeout: nil))))))
                         } else {
-                            subscriber.putNext(.done(.media(.media(.standalone(media: TelegramMediaMap(latitude: value.latitude, longitude: value.longitude, geoPlace: nil, venue: nil, liveBroadcastingTimeout: nil))))))
+                            subscriber.putNext(.done(.media(.media(.standalone(media: TelegramMediaMap(latitude: value.latitude, longitude: value.longitude, heading: nil, accuracyRadius: nil, geoPlace: nil, venue: nil, liveBroadcastingTimeout: nil))))))
                         }
                         subscriber.putCompletion()
                     } else if let value = value as? String {
diff --git a/submodules/SyncCore/Sources/TelegramMediaAction.swift b/submodules/SyncCore/Sources/TelegramMediaAction.swift
index ffd4c61755..63fe26ba31 100644
--- a/submodules/SyncCore/Sources/TelegramMediaAction.swift
+++ b/submodules/SyncCore/Sources/TelegramMediaAction.swift
@@ -45,6 +45,7 @@ public enum TelegramMediaActionType: PostboxCoding, Equatable {
     case botSentSecureValues(types: [SentSecureValueType])
     case peerJoined
     case phoneNumberRequest
+    case geoProximityReached(distance: Int32)
     
     public init(decoder: PostboxDecoder) {
         let rawValue: Int32 = decoder.decodeInt32ForKey("_rawValue", orElse: 0)
@@ -95,6 +96,8 @@ public enum TelegramMediaActionType: PostboxCoding, Equatable {
                 self = .peerJoined
             case 20:
                 self = .phoneNumberRequest
+            case 21:
+                self = .geoProximityReached(distance: (decoder.decodeInt32ForKey("dst", orElse: 0)))
             default:
                 self = .unknown
         }
@@ -180,6 +183,9 @@ public enum TelegramMediaActionType: PostboxCoding, Equatable {
                 encoder.encodeInt32(19, forKey: "_rawValue")
             case .phoneNumberRequest:
                 encoder.encodeInt32(20, forKey: "_rawValue")
+            case let .geoProximityReached(distance):
+                encoder.encodeInt32(21, forKey: "_rawValue")
+                encoder.encodeInt32(distance, forKey: "dst")
         }
     }
     
diff --git a/submodules/SyncCore/Sources/TelegramMediaMap.swift b/submodules/SyncCore/Sources/TelegramMediaMap.swift
index a54f276c1a..7d069ebfe6 100644
--- a/submodules/SyncCore/Sources/TelegramMediaMap.swift
+++ b/submodules/SyncCore/Sources/TelegramMediaMap.swift
@@ -133,6 +133,8 @@ public final class MapVenue: PostboxCoding, Equatable {
 public final class TelegramMediaMap: Media {
     public let latitude: Double
     public let longitude: Double
+    public let heading: Double?
+    public let accuracyRadius: Double?
     public let geoPlace: NamedGeoPlace?
     public let venue: MapVenue?
     public let liveBroadcastingTimeout: Int32?
@@ -140,9 +142,11 @@ public final class TelegramMediaMap: Media {
     public let id: MediaId? = nil
     public let peerIds: [PeerId] = []
     
-    public init(latitude: Double, longitude: Double, geoPlace: NamedGeoPlace?, venue: MapVenue?, liveBroadcastingTimeout: Int32?) {
+    public init(latitude: Double, longitude: Double, heading: Double?, accuracyRadius: Double?, geoPlace: NamedGeoPlace?, venue: MapVenue?, liveBroadcastingTimeout: Int32?) {
         self.latitude = latitude
         self.longitude = longitude
+        self.heading = heading
+        self.accuracyRadius = accuracyRadius
         self.geoPlace = geoPlace
         self.venue = venue
         self.liveBroadcastingTimeout = liveBroadcastingTimeout
@@ -151,6 +155,8 @@ public final class TelegramMediaMap: Media {
     public init(decoder: PostboxDecoder) {
         self.latitude = decoder.decodeDoubleForKey("la", orElse: 0.0)
         self.longitude = decoder.decodeDoubleForKey("lo", orElse: 0.0)
+        self.heading = decoder.decodeOptionalDoubleForKey("hdg")
+        self.accuracyRadius = decoder.decodeOptionalDoubleForKey("acc")
         self.geoPlace = decoder.decodeObjectForKey("gp", decoder: { NamedGeoPlace(decoder: $0) }) as? NamedGeoPlace
         self.venue = decoder.decodeObjectForKey("ve", decoder: { MapVenue(decoder: $0) }) as? MapVenue
         self.liveBroadcastingTimeout = decoder.decodeOptionalInt32ForKey("bt")
@@ -159,6 +165,16 @@ public final class TelegramMediaMap: Media {
     public func encode(_ encoder: PostboxEncoder) {
         encoder.encodeDouble(self.latitude, forKey: "la")
         encoder.encodeDouble(self.longitude, forKey: "lo")
+        if let heading = self.heading {
+            encoder.encodeDouble(heading, forKey: "hdg")
+        } else {
+            encoder.encodeNil(forKey: "hdg")
+        }
+        if let accuracyRadius = self.accuracyRadius {
+            encoder.encodeDouble(accuracyRadius, forKey: "acc")
+        } else {
+            encoder.encodeNil(forKey: "acc")
+        }
         if let geoPlace = self.geoPlace {
             encoder.encodeObject(geoPlace, forKey: "gp")
         } else {
@@ -181,6 +197,12 @@ public final class TelegramMediaMap: Media {
             if self.latitude != other.latitude || self.longitude != other.longitude {
                 return false
             }
+            if self.heading != other.heading {
+                return false
+            }
+            if self.accuracyRadius != other.accuracyRadius {
+                return false
+            }
             if self.geoPlace != other.geoPlace {
                 return false
             }
diff --git a/submodules/TelegramCore/Sources/ChatContextResult.swift b/submodules/TelegramCore/Sources/ChatContextResult.swift
index ab703b262b..60ec1d7a1c 100644
--- a/submodules/TelegramCore/Sources/ChatContextResult.swift
+++ b/submodules/TelegramCore/Sources/ChatContextResult.swift
@@ -424,14 +424,14 @@ extension ChatContextResultMessage {
                 }
                 self = .text(text: message, entities: parsedEntities, disableUrlPreview: (flags & (1 << 0)) != 0, replyMarkup: parsedReplyMarkup)
             case let .botInlineMessageMediaGeo(_, geo, period, replyMarkup):
-                let media = telegramMediaMapFromApiGeoPoint(geo, title: nil, address: nil, provider: nil, venueId: nil, venueType: nil, liveBroadcastingTimeout: period)
+                let media = telegramMediaMapFromApiGeoPoint(geo, title: nil, address: nil, provider: nil, venueId: nil, venueType: nil, liveBroadcastingTimeout: period, heading: nil)
                 var parsedReplyMarkup: ReplyMarkupMessageAttribute?
                 if let replyMarkup = replyMarkup {
                     parsedReplyMarkup = ReplyMarkupMessageAttribute(apiMarkup: replyMarkup)
                 }
                 self = .mapLocation(media: media, replyMarkup: parsedReplyMarkup)
             case let .botInlineMessageMediaVenue(_, geo, title, address, provider, venueId, venueType, replyMarkup):
-                let media = telegramMediaMapFromApiGeoPoint(geo, title: title, address: address, provider: provider, venueId: venueId, venueType: venueType, liveBroadcastingTimeout: nil)
+                let media = telegramMediaMapFromApiGeoPoint(geo, title: title, address: address, provider: provider, venueId: venueId, venueType: venueType, liveBroadcastingTimeout: nil, heading: nil)
                 var parsedReplyMarkup: ReplyMarkupMessageAttribute?
                 if let replyMarkup = replyMarkup {
                     parsedReplyMarkup = ReplyMarkupMessageAttribute(apiMarkup: replyMarkup)
diff --git a/submodules/TelegramCore/Sources/PendingMessageUploadedContent.swift b/submodules/TelegramCore/Sources/PendingMessageUploadedContent.swift
index c6eb0b33c8..ef21c53ddf 100644
--- a/submodules/TelegramCore/Sources/PendingMessageUploadedContent.swift
+++ b/submodules/TelegramCore/Sources/PendingMessageUploadedContent.swift
@@ -142,12 +142,16 @@ func mediaContentToUpload(network: Network, postbox: Postbox, auxiliaryMethods:
         return .single(.content(PendingMessageUploadedContentAndReuploadInfo(content: .media(input, text), reuploadInfo: nil)))
     } else if let map = media as? TelegramMediaMap {
         let input: Api.InputMedia
+        var geoFlags: Int32 = 0
+        if let _ = map.accuracyRadius {
+            geoFlags |= 1 << 0
+        }
         if let liveBroadcastingTimeout = map.liveBroadcastingTimeout {
-            input = .inputMediaGeoLive(flags: 1 << 1, geoPoint: Api.InputGeoPoint.inputGeoPoint(flags: 0, lat: map.latitude, long: map.longitude, accuracyRadius: nil), heading: 0, period: liveBroadcastingTimeout)
+            input = .inputMediaGeoLive(flags: 1 << 1, geoPoint: Api.InputGeoPoint.inputGeoPoint(flags: geoFlags, lat: map.latitude, long: map.longitude, accuracyRadius: map.accuracyRadius.flatMap({ Int32($0) })), heading: 0, period: liveBroadcastingTimeout)
         } else if let venue = map.venue {
-            input = .inputMediaVenue(geoPoint: Api.InputGeoPoint.inputGeoPoint(flags: 0, lat: map.latitude, long: map.longitude, accuracyRadius: nil), title: venue.title, address: venue.address ?? "", provider: venue.provider ?? "", venueId: venue.id ?? "", venueType: venue.type ?? "")
+            input = .inputMediaVenue(geoPoint: Api.InputGeoPoint.inputGeoPoint(flags: geoFlags, lat: map.latitude, long: map.longitude, accuracyRadius: map.accuracyRadius.flatMap({ Int32($0) })), title: venue.title, address: venue.address ?? "", provider: venue.provider ?? "", venueId: venue.id ?? "", venueType: venue.type ?? "")
         } else {
-            input = .inputMediaGeoPoint(geoPoint: Api.InputGeoPoint.inputGeoPoint(flags: 0, lat: map.latitude, long: map.longitude, accuracyRadius: nil))
+            input = .inputMediaGeoPoint(geoPoint: Api.InputGeoPoint.inputGeoPoint(flags: geoFlags, lat: map.latitude, long: map.longitude, accuracyRadius: map.accuracyRadius.flatMap({ Int32($0) })))
         }
         return .single(.content(PendingMessageUploadedContentAndReuploadInfo(content: .media(input, text), reuploadInfo: nil)))
     } else if let poll = media as? TelegramMediaPoll {
diff --git a/submodules/TelegramCore/Sources/ProcessSecretChatIncomingDecryptedOperations.swift b/submodules/TelegramCore/Sources/ProcessSecretChatIncomingDecryptedOperations.swift
index 8ff17a6ce9..ebd7dbd8ee 100644
--- a/submodules/TelegramCore/Sources/ProcessSecretChatIncomingDecryptedOperations.swift
+++ b/submodules/TelegramCore/Sources/ProcessSecretChatIncomingDecryptedOperations.swift
@@ -794,11 +794,11 @@ private func parseMessage(peerId: PeerId, authorId: PeerId, tagLocalIndex: Int32
                     case let .decryptedMessageMediaWebPage(url):
                         parsedMedia.append(TelegramMediaWebpage(webpageId: MediaId(namespace: Namespaces.Media.LocalWebpage, id: arc4random64()), content: .Pending(0, url)))
                     case let .decryptedMessageMediaGeoPoint(lat, long):
-                        parsedMedia.append(TelegramMediaMap(latitude: lat, longitude: long, geoPlace: nil, venue: nil, liveBroadcastingTimeout: nil))
+                        parsedMedia.append(TelegramMediaMap(latitude: lat, longitude: long, heading: nil, accuracyRadius: nil, geoPlace: nil, venue: nil, liveBroadcastingTimeout: nil))
                     case let .decryptedMessageMediaContact(phoneNumber, firstName, lastName, userId):
                         parsedMedia.append(TelegramMediaContact(firstName: firstName, lastName: lastName, phoneNumber: phoneNumber, peerId: userId == 0 ? nil : PeerId(namespace: Namespaces.Peer.CloudUser, id: userId), vCardData: nil))
                     case let .decryptedMessageMediaVenue(lat, long, title, address, provider, venueId):
-                        parsedMedia.append(TelegramMediaMap(latitude: lat, longitude: long, geoPlace: nil, venue: MapVenue(title: title, address: address, provider: provider, id: venueId, type: nil), liveBroadcastingTimeout: nil))
+                        parsedMedia.append(TelegramMediaMap(latitude: lat, longitude: long, heading: nil, accuracyRadius: nil, geoPlace: nil, venue: MapVenue(title: title, address: address, provider: provider, id: venueId, type: nil), liveBroadcastingTimeout: nil))
                     case .decryptedMessageMediaEmpty:
                         break
                 }
@@ -1013,11 +1013,11 @@ private func parseMessage(peerId: PeerId, authorId: PeerId, tagLocalIndex: Int32
                     case let .decryptedMessageMediaWebPage(url):
                         parsedMedia.append(TelegramMediaWebpage(webpageId: MediaId(namespace: Namespaces.Media.LocalWebpage, id: arc4random64()), content: .Pending(0, url)))
                     case let .decryptedMessageMediaGeoPoint(lat, long):
-                        parsedMedia.append(TelegramMediaMap(latitude: lat, longitude: long, geoPlace: nil, venue: nil, liveBroadcastingTimeout: nil))
+                        parsedMedia.append(TelegramMediaMap(latitude: lat, longitude: long, heading: nil, accuracyRadius: nil, geoPlace: nil, venue: nil, liveBroadcastingTimeout: nil))
                     case let .decryptedMessageMediaContact(phoneNumber, firstName, lastName, userId):
                         parsedMedia.append(TelegramMediaContact(firstName: firstName, lastName: lastName, phoneNumber: phoneNumber, peerId: userId == 0 ? nil : PeerId(namespace: Namespaces.Peer.CloudUser, id: userId), vCardData: nil))
                     case let .decryptedMessageMediaVenue(lat, long, title, address, provider, venueId):
-                        parsedMedia.append(TelegramMediaMap(latitude: lat, longitude: long, geoPlace: nil, venue: MapVenue(title: title, address: address, provider: provider, id: venueId, type: nil), liveBroadcastingTimeout: nil))
+                        parsedMedia.append(TelegramMediaMap(latitude: lat, longitude: long, heading: nil, accuracyRadius: nil, geoPlace: nil, venue: MapVenue(title: title, address: address, provider: provider, id: venueId, type: nil), liveBroadcastingTimeout: nil))
                     case .decryptedMessageMediaEmpty:
                         break
                 }
@@ -1251,11 +1251,11 @@ private func parseMessage(peerId: PeerId, authorId: PeerId, tagLocalIndex: Int32
                 case let .decryptedMessageMediaWebPage(url):
                     parsedMedia.append(TelegramMediaWebpage(webpageId: MediaId(namespace: Namespaces.Media.LocalWebpage, id: arc4random64()), content: .Pending(0, url)))
                 case let .decryptedMessageMediaGeoPoint(lat, long):
-                    parsedMedia.append(TelegramMediaMap(latitude: lat, longitude: long, geoPlace: nil, venue: nil, liveBroadcastingTimeout: nil))
+                    parsedMedia.append(TelegramMediaMap(latitude: lat, longitude: long, heading: nil, accuracyRadius: nil, geoPlace: nil, venue: nil, liveBroadcastingTimeout: nil))
                 case let .decryptedMessageMediaContact(phoneNumber, firstName, lastName, userId):
                     parsedMedia.append(TelegramMediaContact(firstName: firstName, lastName: lastName, phoneNumber: phoneNumber, peerId: userId == 0 ? nil : PeerId(namespace: Namespaces.Peer.CloudUser, id: userId), vCardData: nil))
                 case let .decryptedMessageMediaVenue(lat, long, title, address, provider, venueId):
-                    parsedMedia.append(TelegramMediaMap(latitude: lat, longitude: long, geoPlace: nil, venue: MapVenue(title: title, address: address, provider: provider, id: venueId, type: nil), liveBroadcastingTimeout: nil))
+                    parsedMedia.append(TelegramMediaMap(latitude: lat, longitude: long, heading: nil, accuracyRadius: nil, geoPlace: nil, venue: MapVenue(title: title, address: address, provider: provider, id: venueId, type: nil), liveBroadcastingTimeout: nil))
                 case .decryptedMessageMediaEmpty:
                     break
                 }
diff --git a/submodules/TelegramCore/Sources/RequestEditMessage.swift b/submodules/TelegramCore/Sources/RequestEditMessage.swift
index 9cc59e0338..93238bc26a 100644
--- a/submodules/TelegramCore/Sources/RequestEditMessage.swift
+++ b/submodules/TelegramCore/Sources/RequestEditMessage.swift
@@ -252,7 +252,7 @@ private func requestEditMessageInternal(postbox: Postbox, network: Network, stat
     }
 }
 
-public func requestEditLiveLocation(postbox: Postbox, network: Network, stateManager: AccountStateManager, messageId: MessageId, coordinate: (latitude: Double, longitude: Double)?) -> Signal<Void, NoError> {
+public func requestEditLiveLocation(postbox: Postbox, network: Network, stateManager: AccountStateManager, messageId: MessageId, coordinate: (latitude: Double, longitude: Double, accuracyRadius: Int32?)?, heading: Int32?) -> Signal<Void, NoError> {
     return postbox.transaction { transaction -> (Api.InputPeer, TelegramMediaMap)? in
         guard let inputPeer = transaction.getPeer(messageId.peerId).flatMap(apiInputPeer) else {
             return nil
@@ -273,7 +273,11 @@ public func requestEditLiveLocation(postbox: Postbox, network: Network, stateMan
         }
         let inputMedia: Api.InputMedia
         if let coordinate = coordinate, let liveBroadcastingTimeout = media.liveBroadcastingTimeout {
-            inputMedia = .inputMediaGeoLive(flags: 1 << 1, geoPoint: .inputGeoPoint(flags: 0, lat: coordinate.latitude, long: coordinate.longitude, accuracyRadius: nil), heading: 0, period: liveBroadcastingTimeout)
+            var geoFlags: Int32 = 0
+            if let _ = coordinate.accuracyRadius {
+                geoFlags |= 1 << 0
+            }
+            inputMedia = .inputMediaGeoLive(flags: 1 << 1, geoPoint: .inputGeoPoint(flags: geoFlags, lat: coordinate.latitude, long: coordinate.longitude, accuracyRadius: coordinate.accuracyRadius.flatMap({ Int32($0) })), heading: heading ?? 0, period: liveBroadcastingTimeout)
         } else {
             inputMedia = .inputMediaGeoLive(flags: 1 << 0, geoPoint: .inputGeoPoint(flags: 0, lat: media.latitude, long: media.longitude, accuracyRadius: nil), heading: 0, period: nil)
         }
@@ -305,3 +309,45 @@ public func requestEditLiveLocation(postbox: Postbox, network: Network, stateMan
     }
 }
 
+public func requestProximityNotification(postbox: Postbox, network: Network, messageId: MessageId, distance: Int32, coordinate: (latitude: Double, longitude: Double, accuracyRadius: Int32?)) -> Signal<Void, NoError> {
+    return postbox.transaction { transaction -> Api.InputPeer? in
+        return transaction.getPeer(messageId.peerId).flatMap(apiInputPeer)
+    }
+    |> mapToSignal { inputPeer -> Signal<Void, NoError> in
+        guard let inputPeer = inputPeer else {
+            return .complete()
+        }
+        let flags: Int32 = 1 << 0
+        var geoFlags: Int32 = 0
+        if let _ = coordinate.accuracyRadius {
+            geoFlags |= 1 << 0
+        }
+        return network.request(Api.functions.messages.requestProximityNotification(flags: flags, peer: inputPeer, msgId: messageId.id, ownLocation: .inputGeoPoint(flags: geoFlags, lat: coordinate.latitude, long: coordinate.longitude, accuracyRadius: coordinate.accuracyRadius), maxDistance: distance))
+        |> map(Optional.init)
+        |> `catch` { _ -> Signal<Api.Bool?, NoError> in
+            return .single(nil)
+        }
+        |> mapToSignal { _ -> Signal<Void, NoError> in
+            return .complete()
+        }
+    }
+}
+
+public func cancelProximityNotification(postbox: Postbox, network: Network, messageId: MessageId) -> Signal<Void, NoError> {
+    return postbox.transaction { transaction -> Api.InputPeer? in
+        return transaction.getPeer(messageId.peerId).flatMap(apiInputPeer)
+    }
+    |> mapToSignal { inputPeer -> Signal<Void, NoError> in
+        guard let inputPeer = inputPeer else {
+            return .complete()
+        }
+        return network.request(Api.functions.messages.requestProximityNotification(flags: 1 << 1, peer: inputPeer, msgId: messageId.id, ownLocation: nil, maxDistance: nil))
+        |> map(Optional.init)
+        |> `catch` { _ -> Signal<Api.Bool?, NoError> in
+            return .single(nil)
+        }
+        |> mapToSignal { _ -> Signal<Void, NoError> in
+            return .complete()
+        }
+    }
+}
diff --git a/submodules/TelegramCore/Sources/StoreMessage_Telegram.swift b/submodules/TelegramCore/Sources/StoreMessage_Telegram.swift
index 9720779d35..099609b9ee 100644
--- a/submodules/TelegramCore/Sources/StoreMessage_Telegram.swift
+++ b/submodules/TelegramCore/Sources/StoreMessage_Telegram.swift
@@ -255,13 +255,13 @@ func textMediaAndExpirationTimerFromApiMedia(_ media: Api.MessageMedia?, _ peerI
             let mediaContact = TelegramMediaContact(firstName: firstName, lastName: lastName, phoneNumber: phoneNumber, peerId: contactPeerId, vCardData: vcard.isEmpty ? nil : vcard)
             return (mediaContact, nil)
         case let .messageMediaGeo(geo):
-            let mediaMap = telegramMediaMapFromApiGeoPoint(geo, title: nil, address: nil, provider: nil, venueId: nil, venueType: nil, liveBroadcastingTimeout: nil)
+            let mediaMap = telegramMediaMapFromApiGeoPoint(geo, title: nil, address: nil, provider: nil, venueId: nil, venueType: nil, liveBroadcastingTimeout: nil, heading: nil)
             return (mediaMap, nil)
         case let .messageMediaVenue(geo, title, address, provider, venueId, venueType):
-            let mediaMap = telegramMediaMapFromApiGeoPoint(geo, title: title, address: address, provider: provider, venueId: venueId, venueType: venueType, liveBroadcastingTimeout: nil)
+            let mediaMap = telegramMediaMapFromApiGeoPoint(geo, title: title, address: address, provider: provider, venueId: venueId, venueType: venueType, liveBroadcastingTimeout: nil, heading: nil)
             return (mediaMap, nil)
         case let .messageMediaGeoLive(geo, heading, period):
-            let mediaMap = telegramMediaMapFromApiGeoPoint(geo, title: nil, address: nil, provider: nil, venueId: nil, venueType: nil, liveBroadcastingTimeout: period)
+            let mediaMap = telegramMediaMapFromApiGeoPoint(geo, title: nil, address: nil, provider: nil, venueId: nil, venueType: nil, liveBroadcastingTimeout: period, heading: heading)
             return (mediaMap, nil)
         case let .messageMediaDocument(_, document, ttlSeconds):
             if let document = document {
diff --git a/submodules/TelegramCore/Sources/TelegramMediaAction.swift b/submodules/TelegramCore/Sources/TelegramMediaAction.swift
index 5e1b7ec56d..208401144c 100644
--- a/submodules/TelegramCore/Sources/TelegramMediaAction.swift
+++ b/submodules/TelegramCore/Sources/TelegramMediaAction.swift
@@ -58,7 +58,7 @@ func telegramMediaActionFromApiAction(_ action: Api.MessageAction) -> TelegramMe
         case .messageActionContactSignUp:
             return TelegramMediaAction(action: .peerJoined)
         case let .messageActionGeoProximityReached(fromId, toId, distance):
-            return nil
+            return TelegramMediaAction(action: .geoProximityReached(distance: distance))
     }
 }
 
diff --git a/submodules/TelegramCore/Sources/TelegramMediaMap.swift b/submodules/TelegramCore/Sources/TelegramMediaMap.swift
index 5dc6819290..df3b7c0648 100644
--- a/submodules/TelegramCore/Sources/TelegramMediaMap.swift
+++ b/submodules/TelegramCore/Sources/TelegramMediaMap.swift
@@ -4,15 +4,15 @@ import TelegramApi
 
 import SyncCore
 
-func telegramMediaMapFromApiGeoPoint(_ geo: Api.GeoPoint, title: String?, address: String?, provider: String?, venueId: String?, venueType: String?, liveBroadcastingTimeout: Int32?) -> TelegramMediaMap {
+func telegramMediaMapFromApiGeoPoint(_ geo: Api.GeoPoint, title: String?, address: String?, provider: String?, venueId: String?, venueType: String?, liveBroadcastingTimeout: Int32?, heading: Int32?) -> TelegramMediaMap {
     var venue: MapVenue?
     if let title = title {
         venue = MapVenue(title: title, address: address, provider: provider, id: venueId, type: venueType)
     }
     switch geo {
         case let .geoPoint(_, long, lat, accessHash, accuracyRadius):
-            return TelegramMediaMap(latitude: lat, longitude: long, geoPlace: nil, venue: venue, liveBroadcastingTimeout: liveBroadcastingTimeout)
+            return TelegramMediaMap(latitude: lat, longitude: long, heading: heading.flatMap { Double($0) }, accuracyRadius: accuracyRadius.flatMap { Double($0) }, geoPlace: nil, venue: venue, liveBroadcastingTimeout: liveBroadcastingTimeout)
         case .geoPointEmpty:
-            return TelegramMediaMap(latitude: 0.0, longitude: 0.0, geoPlace: nil, venue: venue, liveBroadcastingTimeout: liveBroadcastingTimeout)
+            return TelegramMediaMap(latitude: 0.0, longitude: 0.0, heading: nil, accuracyRadius: nil, geoPlace: nil, venue: venue, liveBroadcastingTimeout: liveBroadcastingTimeout)
     }
 }
diff --git a/submodules/TelegramStringFormatting/Sources/ServiceMessageStrings.swift b/submodules/TelegramStringFormatting/Sources/ServiceMessageStrings.swift
index c35ca10a06..4fd0f1b3f7 100644
--- a/submodules/TelegramStringFormatting/Sources/ServiceMessageStrings.swift
+++ b/submodules/TelegramStringFormatting/Sources/ServiceMessageStrings.swift
@@ -442,6 +442,8 @@ public func universalServiceMessageString(presentationData: (PresentationTheme,
                 attributedString = addAttributesToStringWithRanges(strings.Notification_Joined(authorName), body: bodyAttributes, argumentAttributes: peerMentionsAttributes(primaryTextColor: primaryTextColor, peerIds: [(0, message.author?.id)]))
             case .phoneNumberRequest:
                 attributedString = nil
+            case .geoProximityReached:
+                attributedString = nil
             case .unknown:
                 attributedString = nil
             }
diff --git a/submodules/TelegramUI/Sources/ChatController.swift b/submodules/TelegramUI/Sources/ChatController.swift
index 0bd71dc3ee..314cda923e 100644
--- a/submodules/TelegramUI/Sources/ChatController.swift
+++ b/submodules/TelegramUI/Sources/ChatController.swift
@@ -1088,7 +1088,7 @@ public final class ChatControllerImpl: TelegramBaseController, ChatController, G
                         |> deliverOnMainQueue).start(next: { coordinate in
                             if let strongSelf = self {
                                 if let coordinate = coordinate {
-                                    strongSelf.sendMessages([.message(text: "", attributes: [], mediaReference: .standalone(media: TelegramMediaMap(latitude: coordinate.latitude, longitude: coordinate.longitude, geoPlace: nil, venue: nil, liveBroadcastingTimeout: nil)), replyToMessageId: nil, localGroupingKey: nil)])
+                                    strongSelf.sendMessages([.message(text: "", attributes: [], mediaReference: .standalone(media: TelegramMediaMap(latitude: coordinate.latitude, longitude: coordinate.longitude, heading: nil, accuracyRadius: nil, geoPlace: nil, venue: nil, liveBroadcastingTimeout: nil)), replyToMessageId: nil, localGroupingKey: nil)])
                                 } else {
                                     strongSelf.present(textAlertController(context: strongSelf.context, title: nil, text: strongSelf.presentationData.strings.Login_UnknownError, actions: [TextAlertAction(type: .genericAction, title: strongSelf.presentationData.strings.Common_Cancel, action: {})]), in: .window(.root))
                                 }
diff --git a/submodules/TelegramUI/Sources/ChatRecentActionsHistoryTransition.swift b/submodules/TelegramUI/Sources/ChatRecentActionsHistoryTransition.swift
index 0dd763ed33..6249c33961 100644
--- a/submodules/TelegramUI/Sources/ChatRecentActionsHistoryTransition.swift
+++ b/submodules/TelegramUI/Sources/ChatRecentActionsHistoryTransition.swift
@@ -1037,7 +1037,7 @@ struct ChatRecentActionsEntry: Comparable, Identifiable {
                         return []
                     }, to: &text, entities: &entities)
                     
-                    let mediaMap = TelegramMediaMap(latitude: updated.latitude, longitude: updated.longitude, geoPlace: nil, venue: nil, liveBroadcastingTimeout: nil)
+                    let mediaMap = TelegramMediaMap(latitude: updated.latitude, longitude: updated.longitude, heading: nil, accuracyRadius: nil, geoPlace: nil, venue: nil, liveBroadcastingTimeout: nil)
                     
                     let message = Message(stableId: self.entry.stableId, stableVersion: 0, id: MessageId(peerId: peer.id, namespace: Namespaces.Message.Cloud, id: Int32(bitPattern: self.entry.stableId)), globallyUniqueId: self.entry.event.id, groupingKey: nil, groupInfo: nil, threadId: nil, timestamp: self.entry.event.date, flags: [.Incoming], tags: [], globalTags: [], localTags: [], forwardInfo: nil, author: author, text: text, attributes: [], media: [mediaMap], peers: peers, associatedMessages: SimpleDictionary(), associatedMessageIds: [])
                     return ChatMessageItem(presentationData: self.presentationData, context: context, chatLocation: .peer(peer.id), associatedData: ChatMessageItemAssociatedData(automaticDownloadPeerType: .channel, automaticDownloadNetworkType: .cellular, isRecentActions: true), controllerInteraction: controllerInteraction, content: .message(message: message, read: true, selection: .none, attributes: ChatMessageEntryAttributes()))
diff --git a/submodules/TelegramUI/Sources/OpenChatMessage.swift b/submodules/TelegramUI/Sources/OpenChatMessage.swift
index f4ac6a8238..cdc17aed8c 100644
--- a/submodules/TelegramUI/Sources/OpenChatMessage.swift
+++ b/submodules/TelegramUI/Sources/OpenChatMessage.swift
@@ -82,7 +82,7 @@ func openChatMessageImpl(_ params: OpenChatMessageParams) -> Bool {
                     let controller = legacyLocationController(message: params.message, mapMedia: mapMedia, context: params.context, openPeer: { peer in
                         params.openPeer(peer, .info)
                     }, sendLiveLocation: { coordinate, period in
-                        let outMessage: EnqueueMessage = .message(text: "", attributes: [], mediaReference: .standalone(media: TelegramMediaMap(latitude: coordinate.latitude, longitude: coordinate.longitude, geoPlace: nil, venue: nil, liveBroadcastingTimeout: period)), replyToMessageId: nil, localGroupingKey: nil)
+                        let outMessage: EnqueueMessage = .message(text: "", attributes: [], mediaReference: .standalone(media: TelegramMediaMap(latitude: coordinate.latitude, longitude: coordinate.longitude, heading: nil, accuracyRadius: nil, geoPlace: nil, venue: nil, liveBroadcastingTimeout: period)), replyToMessageId: nil, localGroupingKey: nil)
                         params.enqueueMessage(outMessage)
                     }, stopLiveLocation: {
                         params.context.liveLocationManager?.cancelLiveLocation(peerId: params.message.id.peerId)
diff --git a/submodules/TelegramUI/Sources/PeerInfo/PeerInfoScreen.swift b/submodules/TelegramUI/Sources/PeerInfo/PeerInfoScreen.swift
index 6b0d5bff27..2fe33c23dd 100644
--- a/submodules/TelegramUI/Sources/PeerInfo/PeerInfoScreen.swift
+++ b/submodules/TelegramUI/Sources/PeerInfo/PeerInfoScreen.swift
@@ -3641,7 +3641,7 @@ private final class PeerInfoScreenNode: ViewControllerTracingNode, UIScrollViewD
         }
         let context = self.context
         let presentationData = self.presentationData
-        let mapMedia = TelegramMediaMap(latitude: location.latitude, longitude: location.longitude, geoPlace: nil, venue: MapVenue(title: peer.displayTitle(strings: presentationData.strings, displayOrder: presentationData.nameDisplayOrder), address: location.address, provider: nil, id: nil, type: nil), liveBroadcastingTimeout: nil)
+        let mapMedia = TelegramMediaMap(latitude: location.latitude, longitude: location.longitude, heading: nil, accuracyRadius: nil, geoPlace: nil, venue: MapVenue(title: peer.displayTitle(strings: presentationData.strings, displayOrder: presentationData.nameDisplayOrder), address: location.address, provider: nil, id: nil, type: nil), liveBroadcastingTimeout: nil)
         let locationController = legacyLocationController(message: nil, mapMedia: mapMedia, context: context, openPeer: { _ in }, sendLiveLocation: { _, _ in }, stopLiveLocation: {}, openUrl: { url in
             context.sharedContext.applicationBindings.openUrl(url)
         })
diff --git a/submodules/WatchBridge/Sources/WatchRequestHandlers.swift b/submodules/WatchBridge/Sources/WatchRequestHandlers.swift
index be82c9c4e2..14518597f2 100644
--- a/submodules/WatchBridge/Sources/WatchRequestHandlers.swift
+++ b/submodules/WatchBridge/Sources/WatchRequestHandlers.swift
@@ -203,7 +203,7 @@ final class WatchSendMessageHandler: WatchRequestHandler {
                         messageSignal = .single((.message(text: args.text, attributes: [], mediaReference: nil, replyToMessageId: replyMessageId, localGroupingKey: nil), peerId))
                     } else if let args = subscription as? TGBridgeSendLocationMessageSubscription, let location = args.location {
                         let peerId = makePeerIdFromBridgeIdentifier(args.peerId)
-                        let map = TelegramMediaMap(latitude: location.latitude, longitude: location.longitude, geoPlace: nil, venue: makeVenue(from: location.venue), liveBroadcastingTimeout: nil)
+                        let map = TelegramMediaMap(latitude: location.latitude, longitude: location.longitude, heading: nil, accuracyRadius: nil, geoPlace: nil, venue: makeVenue(from: location.venue), liveBroadcastingTimeout: nil)
                         messageSignal = .single((.message(text: "", attributes: [], mediaReference: .standalone(media: map), replyToMessageId: nil, localGroupingKey: nil), peerId))
                     } else if let args = subscription as? TGBridgeSendStickerMessageSubscription {
                         let peerId = makePeerIdFromBridgeIdentifier(args.peerId)