C# Model.MarkerOptions类代码示例

        private async void setAdress(MarkerOptions pinMarker, GoogleMap.MapClickEventArgs e)
        {
            string adress = "";
            // Obtengo la posible dirección a partir de la latitud y longitud
            Geocoder geocoder = new Geocoder();
            IEnumerable<string> possibleAdresses = await geocoder.GetAddressesForPositionAsync(new Position(e.Point.Latitude, e.Point.Longitude));

            adress = possibleAdresses.ElementAt(0);
            pinMarker.SetTitle(adress);

            // Añado el pin al mapa
            _map.AddMarker(pinMarker).ShowInfoWindow();

            // Comparto el punto en App
            var myApp = App.Current as App;
            myApp.meetingPoint = new MeetingPoint
            {
                Name = adress,
                Place = new Position(e.Point.Latitude, e.Point.Longitude)
            };
        }

        protected override void OnElementPropertyChanged(object sender, System.ComponentModel.PropertyChangedEventArgs e)
        {
            base.OnElementPropertyChanged (sender, e);
            var androidMapView = (MapView)Control;
            var formsMap = (CustomMap)sender;

            if (e.PropertyName.Equals ("VisibleRegion") && !_isDrawnDone) {
                androidMapView.Map.Clear ();

                androidMapView.Map.MarkerClick += HandleMarkerClick;
                androidMapView.Map.MyLocationEnabled = formsMap.IsShowingUser;

                var formsPins = formsMap.CustomPins;

                foreach (var formsPin in formsPins) {
                    var markerWithIcon = new MarkerOptions ();

                    markerWithIcon.SetPosition (new LatLng (formsPin.Position.Latitude, formsPin.Position.Longitude));
                    markerWithIcon.SetTitle (formsPin.Label);
                    markerWithIcon.SetSnippet (formsPin.Address);

                    if (!string.IsNullOrEmpty (formsPin.PinIcon))
                        markerWithIcon.InvokeIcon (BitmapDescriptorFactory.FromAsset (String.Format ("{0}.png", formsPin.PinIcon)));
                    else
                        markerWithIcon.InvokeIcon (BitmapDescriptorFactory.DefaultMarker ());

                    androidMapView.Map.AddMarker (markerWithIcon);
                }

                _isDrawnDone = true;

            }
        }

        protected override void OnCreate(Bundle bundle)
        {
            base.OnCreate(bundle);
            SetContentView(Resource.Layout.FirstView);

            var viewModel = (FirstViewModel) ViewModel;

            var mapFragment = (SupportMapFragment)SupportFragmentManager.FindFragmentById(Resource.Id.map);

            var options = new MarkerOptions();
            options.SetPosition(new LatLng(viewModel.Keith.Location.Lat, viewModel.Keith.Location.Lng));
            options.SetTitle("Keith");
            _keith = mapFragment.Map.AddMarker(options);

            var options2 = new MarkerOptions();
            options2.SetPosition(new LatLng(viewModel.Helen.Location.Lat, viewModel.Helen.Location.Lng));
            options2.SetTitle("Helen");
            _helen = mapFragment.Map.AddMarker(options2);

            var set = this.CreateBindingSet<FirstView, FirstViewModel>();
            set.Bind(_keith)
               .For(m => m.Position)
               .To(vm => vm.Keith.Location)
               .WithConversion(new LocationToLatLngValueConverter(), null);
            set.Bind(_helen)
               .For(m => m.Position)
               .To(vm => vm.Helen.Location)
               .WithConversion(new LocationToLatLngValueConverter(), null);
            set.Apply();

        }

        protected override void OnCreate(Bundle bundle)
        {
            base.OnCreate(bundle);
            SetContentView(Resource.Layout.SecondView);

            var viewModel = (SecondViewModel) ViewModel;

            var mapFragment = (SupportMapFragment)SupportFragmentManager.FindFragmentById(Resource.Id.map);

            var options = new MarkerOptions();
            options.SetPosition(new LatLng(viewModel.Han.Location.Lat, viewModel.Han.Location.Lng));
            options.SetTitle("Han");
            options.Draggable(true);
            var hanMarker = mapFragment.Map.AddMarker(options);

            _han = new MarkerWrapper(hanMarker);

            mapFragment.Map.MarkerDragEnd += (sender, args) =>
                {
                    _han.FirePositionChangedFromMap();
                };

            var set = this.CreateBindingSet<SecondView, SecondViewModel>();
            set.Bind(_han)
               .For(m => m.Position)
               .To(vm => vm.Han.Location)
               .WithConversion(new LocationToLatLngValueConverter(), null);
            set.Apply();

        }

        public MapRoute(GoogleMap map, List<Station> stations)
        {
            _map = map;
            _mapRoutes = new List<Polyline>();
            _mapStations = new List<Marker>();

            // Choose color;
            Color color = Color.DodgerBlue;

            // Create polyline.
            var polyline = new PolylineOptions();
            polyline.InvokeWidth(4f);
            polyline.InvokeColor(color);

            for (var i = 0; i < stations.Count; i++)
            {
                // Add points to polyline.
                var station = stations[i];
                if (station != null && station.latitude != 0f && station.longitude != 0f)
                {
                    var latlng = new Android.Gms.Maps.Model.LatLng(station.latitude, station.longitude);
                    polyline.Add(latlng);
                    // Create marker.
                    var marker = new MarkerOptions();
                    marker.SetPosition(latlng);
                    marker.SetTitle((i + 1) + ". " + station.postName);
                    marker.Draggable(false);
                    marker.SetSnippet("ul. " + station.street);
                    _mapStations.Add(_map.AddMarker(marker));
                }
            }

            // Add polyline to map.
            _mapRoutes.Add(_map.AddPolyline(polyline));
        }

        private void updateEpins()
        {

            var androidMapView = (MapView)Control;
            var formsMap = (Xam.Plugin.MapExtend.Abstractions.MapExtend)Element;

            androidMapView.Map.Clear();

            androidMapView.Map.MarkerClick += HandleMarkerClick;
            androidMapView.Map.MyLocationEnabled = formsMap.IsShowingUser;

            var items = formsMap.EPins;

            foreach (var item in items)
            {
                var markerWithIcon = new MarkerOptions();
                markerWithIcon.SetPosition(new LatLng(item.Location.Latitude, item.Location.Longitude));
                markerWithIcon.SetTitle(string.IsNullOrWhiteSpace(item.Name) ? "-" : item.Name);
                markerWithIcon.SetSnippet(item.Details);

                try
                {
                    markerWithIcon.InvokeIcon(BitmapDescriptorFactory.FromResource(Resources.GetIdentifier(item.ResourceNameImg, "drawable", Context.PackageName)));
                }
                catch (Exception)
                {
                    markerWithIcon.InvokeIcon(BitmapDescriptorFactory.DefaultMarker());
                }

                androidMapView.Map.AddMarker(markerWithIcon);
            }
        }

        public MapRenderer2Android()
            : base()
        {
            WireUpMap();

            MessagingCenter.Subscribe<IEnumerable<HeritageProperty>>(this, MapRenderer2.MESSAGE_ADD_AND_ZOOM_ON_PINS, async (items) =>
            {
                // wait for map
                await WaitForMap();
                   
                // loop all the properties and add them as markers
                foreach (var item in items)
                {
                    // create the marker
                    var m = new MarkerOptions();
                    m.SetPosition(new LatLng(item.Latitude, item.Longitude));
                    m.SetTitle(item.Name);

                    // add to map
                    this.NativeMap.AddMarker(m);
                }

                // zoom in on the pins
                ZoomAndCenterMap(items);
            });

            MessagingCenter.Subscribe<IEnumerable<HeritageProperty>>(this, MapRenderer2.MESSAGE_ZOOM_ON_PINS, (items) =>
            {
                // zoom in on the pins
                ZoomAndCenterMap(items);
            });
        }

        // Function to add data fields passed on from Main Activity (Latitude, Longitude, Address - then adds a tag to marker utilising the address field if there's any)
        public void adddatatomap()
        {
            MarkerOptions opt = new MarkerOptions();
            double lat = Convert.ToDouble(Intent.GetStringExtra("Latitude"));
            double lng = Convert.ToDouble(Intent.GetStringExtra("Longitude"));
            string address = Intent.GetStringExtra("Address");

            LatLng location = new LatLng(lat, lng);

            opt.SetPosition(location);
            opt.SetTitle(address);

            map.AddMarker(opt); // Adds a marker to map based on the address that was past on from our Main Activity

            // Positioning the camera to show the marker based on fields parameter as set below
            CameraPosition.Builder builder = CameraPosition.InvokeBuilder();
            builder.Target(location);
            builder.Zoom(15);
            builder.Bearing(90);
            builder.Tilt(65);
            CameraPosition cameraPosition = builder.Build();
            CameraUpdate cameraUpdate = CameraUpdateFactory.NewCameraPosition(cameraPosition);

            map.MoveCamera(cameraUpdate);
            // Marker window clicked event
            map.InfoWindowClick += map_InfoWindowClick;
            // Marker dragged event
            map.MarkerDragEnd += map_MarkerDragEnd;
        }

		private void UpdatePins()
		{
			var androidMapView = (MapView)Control;
			var formsMap = (ExtendedMap)Element;

			androidMapView.Map.Clear ();

			androidMapView.Map.MarkerClick += HandleMarkerClick;
			androidMapView.Map.MyLocationEnabled = formsMap.IsShowingUser;

			var items = formsMap.Items;

			foreach (var item in items) {
				var markerWithIcon = new MarkerOptions ();
				markerWithIcon.SetPosition (new LatLng (item.Location.Latitude, item.Location.Longitude));
				markerWithIcon.SetTitle (string.IsNullOrWhiteSpace(item.Name) ? "-" : item.Name);
				markerWithIcon.SetSnippet (item.Details);

				try
				{
					markerWithIcon.InvokeIcon(BitmapDescriptorFactory.FromResource(GetPinIcon()));
				}
				catch (Exception)
				{
					markerWithIcon.InvokeIcon(BitmapDescriptorFactory.DefaultMarker());
				}

				androidMapView.Map.AddMarker (markerWithIcon);
			}
		}

		protected override void OnResume ()
		{
			base.OnResume ();

			// Get a handle on the map element
			_mapFragment = FragmentManager.FindFragmentById(Resource.Id.map) as MapFragment;
			_map = _mapFragment.Map;

			// Set the map type 
			_map.MapType = GoogleMap.MapTypeNormal;

			// show user location
			_map.MyLocationEnabled = true;

			// setup a location manager
			_locationManager = GetSystemService(Context.LocationService) as LocationManager;

			// Add points on the map
			MarkerOptions marker1 = new MarkerOptions()
				.SetPosition(Location_Xamarin)
				.SetTitle("Xamarin")
				.InvokeIcon(BitmapDescriptorFactory.DefaultMarker(BitmapDescriptorFactory.HueBlue));
			_map.AddMarker(marker1);

			MarkerOptions marker2 = new MarkerOptions()
			    .SetPosition(Location_Atlanta)
			    .SetTitle("Atlanta, GA")
			    .InvokeIcon(BitmapDescriptorFactory.DefaultMarker(BitmapDescriptorFactory.HueRed));
			_map.AddMarker(marker2);

			// Add custom marker images on the map
			AddMonkeyMarkersToMap();

			// Add custom arrow callout on map
			AddInitialNewYorkBarToMap();

			// Add custom overlay image on the map
			PositionChicagoGroundOverlay(Location_Chicago);

			// use a generic location provider instead
			Criteria locationCriteria = new Criteria();
			locationCriteria.Accuracy = Accuracy.Coarse;
			locationCriteria.PowerRequirement = Power.Medium;

			var locationProvider = _locationManager.GetBestProvider(locationCriteria, true);
			if (locationProvider != null)
			{
				_locationManager.RequestLocationUpdates(locationProvider, 2000, 1, this);
			} else
			{
				Log.Info("error", "Best provider is not available. Does the device have location services enabled?");
			}

			// TODO: Step 4a - attach map handler for marker touch
//            _map.MarkerClick += MapOnMarkerClick;

			// TODO: Step 4c - attach map handler for info window touch
//			_map.InfoWindowClick += HandleInfoWindowClick;
		}

 private void addEvent(net.cloudapp.geteventinfo.Eventas event1)
 {
     MarkerOptions marker = new MarkerOptions();
     marker.SetPosition(new LatLng(event1.latitude, event1.longitude));
     marker.SetTitle(event1.eventname);
     marker.SetSnippet(event1.description);
     marker.SetIcon(BitmapDescriptorFactory.FromAsset("f.png"));
     gMap.AddMarker(marker);
 }

 public EntityMarker(BankEntity entity, IconType iconType)
 {
     this.Entity = entity;
     this.MarkerOptions = new MarkerOptions ();
     this.MarkerOptions.SetTitle (entity.Description());
     this.MarkerOptions.SetPosition (new LatLng(entity.Latitude, entity.Longitude));
     this.Type = MarkerType.Regular;
     IconType = iconType;
 }

 public void InitMarkers()
 {
     foreach (var element in ListMarkers) {
         MarkerOptions markerOptions = new MarkerOptions ();
         markerOptions.SetPosition (new LatLng (element.Coordinate.Latitude, element.Coordinate.Longitude));
         markerOptions.SetIcon(BitmapDescriptorFactory.DefaultMarker ());
         var marker = this.map.AddMarker (markerOptions);
         this.listMarkers.Add (marker);
     }
 }

        private void CreateMarker()
        {
            var latLng = new LatLng(55.816887, 12.532878);

            var markerOptions = new MarkerOptions()
                .SetPosition(latLng)
                .Draggable(true);
            _meMarker = _map.AddMarker(markerOptions);
            _map.AnimateCamera(CameraUpdateFactory.NewLatLngZoom(latLng, 13));
        }

        public static List<MarkerOptions> FindCar()
        {
            List<MarkerOptions> markers = new List<MarkerOptions>();

            locationsFile = System.Environment.GetFolderPath(System.Environment.SpecialFolder.Personal);
            locationsFile = Path.Combine(locationsFile, "locations.txt");

            IEnumerable<string> lines;

            if (File.Exists (locationsFile)) {
                lines = File.ReadLines (locationsFile);
            } else {
                return new List<MarkerOptions> ();
            }

            List<LocationRecord> records = new List<LocationRecord>();

            foreach (string line in lines ){
                LocationRecord record = JsonConvert.DeserializeObject<LocationRecord> (line);
                records.Add(record);
            }

            IEnumerable<string> speed = from record in records
                select record.calculatedSpeed > speedLimit ? "fast": "slow";
            string[] speeds = speed.ToArray();

            int i = 0;

            for(i=0; i<speeds.Count(); i++) {
                if (i > 0)
                {
                    if (speeds[i] != speeds[i - 1] && speeds[i] == "slow")
                    {
                        int fasts = CountFasts(speeds, i);
                        int slows = CountSlows(speeds, i);

                        long fastTime = records[i].unixTime - records[i-fasts].unixTime;
                        long slowTime = -( records[i].unixTime - records[i+slows].unixTime );

                        if (fastTime > millisBefore && slowTime > millisAfter && (DateTime.Now - records[i].time).TotalDays < 3)
                        {
                            MarkerOptions options = new MarkerOptions ();
                            options.SetPosition (new LatLng (records[i].latitude, records[i].longitude));
                            options.SetTitle (records[i].time.ToShortTimeString ());
                            options.SetSnippet (!double.IsNaN(records[i].recordedSpeed)?"Speed: " + String.Format ("{0:0.00}", records[i].recordedSpeed*3.6) + " km/h":"Speed: " + String.Format ("{0:0.00}", records[i].calculatedSpeed*3.6) + " km/h");
                            markers.Add(options);
                        }
                    }
                }
            }

            return markers;
        }