यह निर्धारित करें कि MKMapView को खींचा / स्थानांतरित किया गया था या नहीं

Question 1

क्या यह निर्धारित करने का कोई तरीका है कि क्या MKMapView को घसीटा गया था?

मैं हर बार केंद्र स्थान प्राप्त करना चाहता हूं जब कोई उपयोगकर्ता मानचित्र का उपयोग करता है, CLLocationCoordinate2D centre = [locationMap centerCoordinate];लेकिन मुझे एक प्रतिनिधि विधि या कुछ और चाहिए जो उपयोगकर्ता द्वारा नक्शे के साथ नेविगेट करते ही आग लग जाए।

अग्रिम में धन्यवाद

Question 2

को देखो MKMapViewDelegate संदर्भ।

विशेष रूप से, ये विधियाँ उपयोगी हो सकती हैं:

- (void)mapView:(MKMapView *)mapView regionWillChangeAnimated:(BOOL)animated
- (void)mapView:(MKMapView *)mapView regionDidChangeAnimated:(BOOL)animated

सुनिश्चित करें कि आपके नक्शे के प्रतिनिधि की संपत्ति सेट है, इसलिए उन तरीकों को बुलाया जाता है।

Question 3

जब किसी कारण से क्षेत्र बदला जाता है तो स्वीकृत उत्तर में कोड फायर करता है। एक मानचित्र खींचें का ठीक से पता लगाने के लिए आपको एक UIPanGestureRecognizer जोड़ना होगा। Btw, यह ड्रैग जेस्चर पहचानकर्ता (पैनिंग = ड्रैगिंग) है।

चरण 1: viewDidLoad में जेस्चर पहचानकर्ता जोड़ें:

-(void) viewDidLoad {
    [super viewDidLoad];
    UIPanGestureRecognizer* panRec = [[UIPanGestureRecognizer alloc] initWithTarget:self action:@selector(didDragMap:)];
    [panRec setDelegate:self];
    [self.mapView addGestureRecognizer:panRec];
}

चरण 2: प्रोटोकॉल UIGestureRecognizerDelegate दृश्य नियंत्रक में जोड़ें ताकि यह प्रतिनिधि के रूप में काम करे।

@interface MapVC : UIViewController <UIGestureRecognizerDelegate, ...>

चरण 3: और MKIPView में पहले से मौजूद जेस्चर पहचानकर्ताओं के साथ काम करने के लिए UIPanGestureRecognizer के लिए निम्न कोड जोड़ें:

- (BOOL)gestureRecognizer:(UIGestureRecognizer *)gestureRecognizer shouldRecognizeSimultaneouslyWithGestureRecognizer:(UIGestureRecognizer *)otherGestureRecognizer {
    return YES;
}

चरण 4: यदि आप प्रति ड्रैग के बजाय 50 बार एक बार अपनी विधि को कॉल करना चाहते हैं, तो यह पता लगाएं कि आपके चयनकर्ता में "ड्रैग एंडेड" स्थिति है:

- (void)didDragMap:(UIGestureRecognizer*)gestureRecognizer {
    if (gestureRecognizer.state == UIGestureRecognizerStateEnded){
        NSLog(@"drag ended");
    }
}

Question 4

यह एकमात्र तरीका है जो मेरे लिए काम करता है जो पैन और साथ ही उपयोगकर्ता द्वारा शुरू किए गए ज़ूम परिवर्तनों का पता लगाता है:

- (BOOL)mapViewRegionDidChangeFromUserInteraction
{
    UIView *view = self.mapView.subviews.firstObject;
    //  Look through gesture recognizers to determine whether this region change is from user interaction
    for(UIGestureRecognizer *recognizer in view.gestureRecognizers) {
        if(recognizer.state == UIGestureRecognizerStateBegan || recognizer.state == UIGestureRecognizerStateEnded) {
            return YES;
        }
    }

    return NO;
}

static BOOL mapChangedFromUserInteraction = NO;

- (void)mapView:(MKMapView *)mapView regionWillChangeAnimated:(BOOL)animated
{
    mapChangedFromUserInteraction = [self mapViewRegionDidChangeFromUserInteraction];

    if (mapChangedFromUserInteraction) {
        // user changed map region
    }
}

- (void)mapView:(MKMapView *)mapView regionDidChangeAnimated:(BOOL)animated
{
    if (mapChangedFromUserInteraction) {
        // user changed map region
    }
}

Question 5

(बस) @ mobi के शानदार समाधान का स्विफ्ट संस्करण :

private var mapChangedFromUserInteraction = false

private func mapViewRegionDidChangeFromUserInteraction() -> Bool {
    let view = self.mapView.subviews[0]
    //  Look through gesture recognizers to determine whether this region change is from user interaction
    if let gestureRecognizers = view.gestureRecognizers {
        for recognizer in gestureRecognizers {
            if( recognizer.state == UIGestureRecognizerState.Began || recognizer.state == UIGestureRecognizerState.Ended ) {
                return true
            }
        }
    }
    return false
}

func mapView(mapView: MKMapView, regionWillChangeAnimated animated: Bool) {
    mapChangedFromUserInteraction = mapViewRegionDidChangeFromUserInteraction()
    if (mapChangedFromUserInteraction) {
        // user changed map region
    }
}

func mapView(mapView: MKMapView, regionDidChangeAnimated animated: Bool) {
    if (mapChangedFromUserInteraction) {
        // user changed map region
    }
}

Question 6

ऊपर दिए गए जैनो के जवाब के लिए स्विफ्ट 3 समाधान :

प्रोटोकॉल UIGestureRecognizerDelegate को अपने ViewController में जोड़ें

class MyViewController: UIViewController, UIGestureRecognizerDelegate

UIPanGestureRecognizer बनाएँ viewDidLoadऔर delegateस्वयं पर सेट करें

viewDidLoad() {
    // add pan gesture to detect when the map moves
    let panGesture = UIPanGestureRecognizer(target: self, action: #selector(self.didDragMap(_:)))

    // make your class the delegate of the pan gesture
    panGesture.delegate = self

    // add the gesture to the mapView
    mapView.addGestureRecognizer(panGesture)
}

एक प्रोटोकॉल विधि जोड़ें ताकि आपका जेस्चर पहचानकर्ता मौजूदा MKMapView इशारों के साथ काम करे

func gestureRecognizer(_ gestureRecognizer: UIGestureRecognizer, shouldRecognizeSimultaneouslyWith otherGestureRecognizer: UIGestureRecognizer) -> Bool {
    return true
}

अपने पैन जेस्चर में चयनकर्ता द्वारा कहा जाने वाला तरीका जोड़ें

func didDragMap(_ sender: UIGestureRecognizer) {
    if sender.state == .ended {

        // do something here

    }
}

Question 7

मेरे अनुभव में, "टाइप करते समय खोज" के समान, मैंने पाया कि एक टाइमर सबसे विश्वसनीय समाधान है। यह पैनिंग, पिंचिंग, रोटेटिंग, टैपिंग, डबल टैपिंग, आदि के लिए अतिरिक्त जेस्चर पहचानकर्ताओं को जोड़ने की आवश्यकता को हटाता है।

समाधान सरल है:

जब नक्शा क्षेत्र बदलता है, तो टाइमर सेट / रीसेट करें

जब टाइमर फायर करता है, तो नए क्षेत्र के लिए मार्कर लोड करें

import MapKit

class MyViewController: MKMapViewDelegate {

    @IBOutlet var mapView: MKMapView!
    var mapRegionTimer: NSTimer?

    // MARK: MapView delegate

    func mapView(mapView: MKMapView, regionDidChangeAnimated animated: Bool) {
        setMapRegionTimer()
    }

    func setMapRegionTimer() {
        mapRegionTimer?.invalidate()
        // Configure delay as bet fits your application
        mapRegionTimer = NSTimer.scheduledTimerWithTimeInterval(1.0, target: self, selector: "mapRegionTimerFired:", userInfo: nil, repeats: false)
    }

    func mapRegionTimerFired(sender: AnyObject) {
        // Load markers for current region:
        //   mapView.centerCoordinate or mapView.region
    }

}

Question 8

एक और संभावित समाधान है टचसेम्प्लिमेंट को लागू करना: (या टचएंड :, इत्यादि) व्यू कंट्रोलर में जो आपके मैप व्यू को रखता है, जैसे:

-(void)touchesMoved:(NSSet *)touches withEvent:(UIEvent *)event
{
    [super touchesMoved:touches withEvent:event];

    for (UITouch * touch in touches) {
        CGPoint loc = [touch locationInView:self.mapView];
        if ([self.mapView pointInside:loc withEvent:event]) {
            #do whatever you need to do
            break;
        }
    }
}

यह कुछ मामलों में, इशारा पहचानने वालों का उपयोग करने की तुलना में सरल हो सकता है।

Question 9

आप इंटरफ़ेस बिल्डर में अपने नक्शे में एक जेस्चर पहचानकर्ता भी जोड़ सकते हैं। इसे अपने व्यू कॉन्ट्रोलर में एक्शन के लिए एक आउटलेट तक लिंक करें, मैंने अपना "मैपड्राग" कहा है ...

तो फिर आप अपने viewController .m में ऐसा कुछ करेंगे:

- (IBAction)mapDrag:(UIPanGestureRecognizer *)sender {
    if(sender.state == UIGestureRecognizerStateBegan){
        NSLog(@"drag started");
    }
}

सुनिश्चित करें कि आपके पास यह भी है:

- (BOOL)gestureRecognizer:(UIGestureRecognizer *)gestureRecognizer shouldRecognizeSimultaneouslyWithGestureRecognizer:(UIGestureRecognizer *)otherGestureRecognizer {
    return YES;
}

निश्चित रूप से आपको अपने दृश्य को काम करने के लिए अपने .h फ़ाइल में एक UIGestureRecognizerDelegate में UCestureRecognizerDelegate बनाना होगा।

अन्यथा नक्शे का उत्तरदाता केवल एक ही है जो इशारे की घटना को सुनता है।

Question 10

यह पहचानने के लिए कि मानचित्र पर कोई इशारा कब समाप्त हुआ:

[ https://web.archive.org/web/20150215221143/http://b2cloud.com.au/tutorial/mkmapview-determining-whether-region-change-is-from-user-interaction/ )

उपयोगकर्ता द्वारा ज़ूम करने / घूमने / घूमने / घसीटने के बाद केवल डेटाबेस क्वेरी करने के लिए यह बहुत उपयोगी है।

मेरे लिए, क्षेत्रनि: शुल्कअनुरक्षित विधि केवल इशारे के बाद ही कॉल की गई थी, और ड्रैग / ज़ूम / रोटेट करते समय कई बार कॉल नहीं किया गया था, लेकिन यह जानना उपयोगी है कि यह एक इशारे के कारण था या नहीं।

Question 11

इन समाधानों में से एक बहुत हैडी पर है / स्विफ्ट का इरादा क्या है, इसलिए मैंने एक क्लीनर समाधान का विकल्प चुना।

मैं बस MKMapView को उप-वर्ग करता हूं और स्पर्श को ओवरराइड करता हूं। हालांकि इस स्निपेट में इसे शामिल नहीं किया गया है, मैं आंदोलन के संबंध में जो भी जानकारी चाहता हूं, उस पर पारित होने के लिए एक प्रतिनिधि या अधिसूचना बनाने की सिफारिश करूंगा।

import MapKit

class MapView: MKMapView {
    override func touchesMoved(_ touches: Set<UITouch>, with event: UIEvent?) {
        super.touchesMoved(touches, with: event)

        print("Something moved")
    }
}

आपको इस उपवर्ग को इंगित करने के लिए अपनी स्टोरीबोर्ड फ़ाइलों पर कक्षा को अपडेट करने की आवश्यकता होगी, साथ ही साथ अन्य साधनों के माध्यम से आपके द्वारा बनाए गए किसी भी नक्शे को संशोधित करना होगा।

जैसा कि टिप्पणियों में कहा गया है, Apple उपवर्ग के उपयोग को हतोत्साहित करता है MKMapView। हालांकि यह डेवलपर के विवेक पर पड़ता है, यह विशेष उपयोग मानचित्र के व्यवहार को संशोधित नहीं करता है और मेरे लिए तीन साल से अधिक समय तक घटना के बिना काम किया है। हालांकि, पिछला प्रदर्शन भविष्य की अनुकूलता को इंगित नहीं करता है, इसलिए कैवेट एम्प्टर ।

Question 12

जैनो के जवाब ने मेरे लिए काम किया, इसलिए मैंने सोचा कि मैं स्विफ्ट 4 / एक्सकोड 9 के लिए एक अद्यतन संस्करण छोड़ दूंगा क्योंकि मैं विशेष रूप से ऑब्जेक्टिव सी में कुशल नहीं हूं और मुझे यकीन है कि कुछ अन्य हैं जो या तो नहीं हैं।

चरण 1: इस कोड को viewDidLoad में जोड़ें:

let panGesture = UIPanGestureRecognizer(target: self, action: #selector(didDragMap(_:)))
panGesture.delegate = self

चरण 2: सुनिश्चित करें कि आपकी कक्षा UIGestureRecognizerDelegate के अनुरूप है:

class MapViewController: UIViewController, MKMapViewDelegate, CLLocationManagerDelegate, UIGestureRecognizerDelegate {

चरण 3: अपने इशारों को अन्य इशारों के साथ काम करने के लिए सुनिश्चित करने के लिए निम्नलिखित फ़ंक्शन जोड़ें:

func gestureRecognizer(_ gestureRecognizer: UIGestureRecognizer, shouldRecognizeSimultaneouslyWith otherGestureRecognizer: UIGestureRecognizer) -> Bool {
    return true
}

चरण 4: और यह सुनिश्चित करने के लिए कि आपका तरीका "खींचें प्रति 50 बार" नहीं है, जैसा कि जानो सही बताता है:

@objc func didDragMap(_ gestureRecognizer: UIPanGestureRecognizer) {
    if (gestureRecognizer.state == UIGestureRecognizerState.ended) {
        redoSearchButton.isHidden = false
        resetLocationButton.isHidden = false
    }
}

* अंतिम चरण में @objc के अतिरिक्त पर ध्यान दें। XCode आपके फ़ंक्शन पर इस उपसर्ग को संकलित करने के लिए बाध्य करेगा।

Question 13

आप एनिमेटेड प्रॉपर्टी की जाँच कर सकते हैं यदि गलत है तो उपयोगकर्ता मानचित्र खींचता है

 func mapView(_ mapView: MKMapView, regionDidChangeAnimated animated: Bool) {
    if animated == false {
        //user dragged map
    }
}

Question 14

मुझे पता है कि यह एक पुरानी पोस्ट है, लेकिन यहां मेरे स्विफ्ट 4/5 कोड के जैनो के उत्तर के सफेद पैन और चुटकी के इशारे हैं।

class MapViewController: UIViewController, MapViewDelegate {

    override func viewDidLoad() {
        super.viewDidLoad()

        let panGesture = UIPanGestureRecognizer(target: self, action: #selector(self.didDragMap(_:)))
        let pinchGesture = UIPinchGestureRecognizer(target: self, action: #selector(self.didPinchMap(_:)))
        panGesture.delegate = self
        pinchGesture.delegate = self
        mapView.addGestureRecognizer(panGesture)
        mapView.addGestureRecognizer(pinchGesture)
    }

}

extension MapViewController: UIGestureRecognizerDelegate {

    func gestureRecognizer(_ gestureRecognizer: UIGestureRecognizer, shouldRecognizeSimultaneouslyWith otherGestureRecognizer: UIGestureRecognizer) -> Bool {
        return true
    }

    @objc func didDragMap(_ sender: UIGestureRecognizer) {
        if sender.state == .ended {
            //code here
        }
    }

    @objc func didPinchMap(_ sender: UIGestureRecognizer) {
        if sender.state == .ended {
            //code here
        }
    }
}

का आनंद लें!

Question 15

मैं मानचित्र के केंद्र में एक एनोटेशन करने की कोशिश कर रहा था जो हमेशा नक्शे के केंद्र में होता है, चाहे वह कोई भी उपयोग करता हो। मैंने ऊपर बताए गए कई तरीकों की कोशिश की, और उनमें से कोई भी पर्याप्त अच्छा नहीं था। मुझे अंततः इसे हल करने का एक बहुत ही सरल तरीका मिला, अन्ना के जवाब से उधार लेना और एनेको के जवाब के साथ संयोजन करना। यह मूल रूप से एक खींचें की शुरुआत के रूप में इस क्षेत्रविलीचेंजएनिमेटेड को मानता है, और एक के अंत के रूप में क्षेत्रडायरेक्ट ट्रांसमिट किया गया है, और वास्तविक समय में पिन को अपडेट करने के लिए एक टाइमर का उपयोग करता है:

var mapRegionTimer: Timer?
public func mapView(_ mapView: MKMapView, regionWillChangeAnimated animated: Bool) {
    mapRegionTimer?.invalidate()
    mapRegionTimer = Timer.scheduledTimer(withTimeInterval: 0.01, repeats: true, block: { (t) in
        self.myAnnotation.coordinate = CLLocationCoordinate2DMake(mapView.centerCoordinate.latitude, mapView.centerCoordinate.longitude);
        self.myAnnotation.title = "Current location"
        self.mapView.addAnnotation(self.myAnnotation)
    })
}
public func mapView(_ mapView: MKMapView, regionDidChangeAnimated animated: Bool) {
    mapRegionTimer?.invalidate()
}

Question 16

यहाँ कोड दर्ज करें। मैं इसे सबसे आसान तरीके से लागू करने में कामयाब रहा, जो मानचित्र के साथ सभी इंटरैक्शन को संभालता है (1/2 / एन उंगलियों के साथ टैपिंग / डबल / एन टैपिंग, 1/2 / एन उंगलियों के साथ पैन, चुटकी और घुमाव।

gesture recognizerमैप व्यू के कंटेनर को बनाएं और जोड़ें
gesture recognizer's delegateकिसी वस्तु को लागू करने के लिए सेट करेंUIGestureRecognizerDelegate
लागू करने की gestureRecognizer(_ gestureRecognizer: UIGestureRecognizer, shouldReceive touch: UITouch)विधि

private func setupGestureRecognizers()
{
    let gestureRecognizer = UITapGestureRecognizer(target: nil, action: nil)
    gestureRecognizer.delegate = self
    self.addGestureRecognizer(gestureRecognizer)
}   

func gestureRecognizer(_ gestureRecognizer: UIGestureRecognizer, shouldReceive touch: UITouch) -> Bool
{
    self.delegate?.mapCollectionViewBackgroundTouched(self)
    return false
}

Question 17

सबसे पहले , सुनिश्चित करें कि आपका वर्तमान दृश्य नियंत्रक नक्शे का एक प्रतिनिधि है। इसलिए अपने मैप व्यू प्रतिनिधि को स्वयं सेट करें और MKMapViewDelegateअपने व्यू कंट्रोलर में जोड़ें । नीचे उदाहरण है।

class Location_Popup_ViewController: UIViewController, MKMapViewDelegate {
   // Your view controller stuff
}

और इसे अपने मैप व्यू में जोड़ें

var myMapView: MKMapView = MKMapView()
myMapView.delegate = self

दूसरा , इस फ़ंक्शन को जोड़ें, जिसे मैप किए जाने पर निकाल दिया जाता है। यह किसी भी एनिमेशन को फ़िल्टर करेगा और यदि इंटरैक्ट करेगा तो केवल फायर करेगा।

func mapView(_ mapView: MKMapView, regionDidChangeAnimated animated: Bool) {
   if !animated {
       // User must have dragged this, filters out all animations
       // PUT YOUR CODE HERE
   }
}