Offseting le centre de la MapFragment pour une animation le déplacement de la cible lat/lng et le niveau de zoom

La plus récente version de la pièce de la bibliothèque de services ajoute un setPadding() fonction de GoogleMap. Ce rembourrage va projeter tous les mouvements de caméra pour le décalage de la carte du centre. Ce document décrit en outre comment la carte de rembourrage se comporte.

La question initialement posée ici peuvent maintenant être simplement résolu par l'ajout de remplissage à gauche de l'équivalent de la largeur de la gauche mise en page.

mMap.setPadding(leftPx, topPx, rightPx, bottomPx);

Edit: Le code ci-dessous est pour le obsolète v1 cartes. Ceci AFIN de répondre à ces états à exécuter des actions similaires dans la v2: Comment obtenir la Latitude/Longitude durée de Google Map V2 pour Android

Les principales méthodes dont vous avez besoin doivent travailler en long/lat et les pourcentages au lieu de pixels. Maintenant, la mapview un zoom autour du centre de la carte, et de passer ensuite à "recentrer" le pin dans la zone exposée. Vous pouvez obtenir la largeur après le zoom en degrés, facteur dans certaines écran de biais, puis recentrer la carte. Voici un exemple de capture d'écran du code ci-dessous dans l'action après avoir appuyé sur le"+": avant

après
Code principal:

@Override
            public void onZoom(boolean zoomIn) {
                //TODO Auto-generated method stub
                controller.setZoom(zoomIn ? map.getZoomLevel()+1 : map.getZoomLevel()-1);
                int bias = (int) (map.getLatitudeSpan()* 1.0/3.0); //a fraction of your choosing
                map.getLongitudeSpan();
                controller.animateTo(new GeoPoint(yourLocation.getLatitudeE6(),yourLocation.getLongitudeE6()-bias));

            }

Tous les code:

    package com.example.testmapview;
import com.google.android.maps.GeoPoint;
import com.google.android.maps.ItemizedOverlay;
import com.google.android.maps.MapActivity;
import com.google.android.maps.MapController;
import com.google.android.maps.MapView;
import android.os.Bundle;
import android.app.Activity;
import android.graphics.drawable.Drawable;
import android.view.Menu;
import android.widget.ZoomButtonsController;
import android.widget.ZoomButtonsController.OnZoomListener;
public class MainActivity extends MapActivity {
MapView map;
GeoPoint yourLocation;
MapController controller;
ZoomButtonsController zoomButtons;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
map=(MapView)findViewById(R.id.mapview);
map.setBuiltInZoomControls(true);
controller = map.getController();
zoomButtons = map.getZoomButtonsController();
zoomButtons.setOnZoomListener(new OnZoomListener(){
@Override
public void onVisibilityChanged(boolean arg0) {
//TODO Auto-generated method stub
}
@Override
public void onZoom(boolean zoomIn) {
//TODO Auto-generated method stub
controller.setZoom(zoomIn ? map.getZoomLevel()+1 : map.getZoomLevel()-1);
int bias = (int) (map.getLatitudeSpan()* 1.0/3.0); //a fraction of your choosing
map.getLongitudeSpan();
controller.animateTo(new GeoPoint(yourLocation.getLatitudeE6(),yourLocation.getLongitudeE6()-bias));
}
});
//Dropping a pin, setting center
Drawable marker=getResources().getDrawable(android.R.drawable.star_big_on);
MyItemizedOverlay myItemizedOverlay = new MyItemizedOverlay(marker);
map.getOverlays().add(myItemizedOverlay);
yourLocation = new GeoPoint(0, 0);
controller.setCenter(yourLocation);
myItemizedOverlay.addItem(yourLocation, "myPoint1", "myPoint1");
controller.setZoom(5);
}
@Override
public boolean onCreateOptionsMenu(Menu menu) {
//Inflate the menu; this adds items to the action bar if it is present.
getMenuInflater().inflate(R.menu.activity_main, menu);
return true;
}
@Override
protected boolean isRouteDisplayed() {
//TODO Auto-generated method stub
return false;
}
}

et une structure de base:

<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
package="com.example.testmapview"
android:versionCode="1"
android:versionName="1.0" >
<meta-data
android:name="com.google.android.maps.v2.API_KEY"
android:value="YOURKEYHERE:)"/>
<uses-sdk
android:minSdkVersion="8"
android:targetSdkVersion="16" />
<uses-permission android:name="android.permission.INTERNET" /> 
<application
android:allowBackup="true"
android:icon="@drawable/ic_launcher"
android:label="@string/app_name"
android:theme="@style/AppTheme" >
<uses-library android:name="com.google.android.maps"/>
<activity
android:name="com.example.testmapview.MainActivity"
android:label="@string/app_name" >
<intent-filter>
<action android:name="android.intent.action.MAIN" />
<category android:name="android.intent.category.LAUNCHER" />
</intent-filter>
</activity>
</application>
</manifest>

Si ce n'est pas de répondre complètement à votre question, s'il vous plaît laissez-moi savoir que c'était une expérience amusante à jouer avec.

Le moyen le plus facile serait de la chaîne d'animations de caméra. Tout d'abord vous zoom normalement à votre image #2 à l'aide de animateCamera avec 3 paramètres et dans CancellableCallback.onFinish - vous de faire vos calculs de projection et d'animer à l'aide de votre code de changer de centre.

Je crois (n'a pas à le tester) ce sera très bien si vous définissez quelques bonnes valeurs pour l'animation de la durée pour les deux animations. Peut-être deuxième animation devrait être beaucoup plus rapide que la première. Aussi, si votre transparent, surmonté de Vue n'est pas visible lorsque aucun marqueur est sélectionné, une belle UX serait pour animer il en de gauche au cours de la deuxième animation.

À la dure serait de mettre en place votre propre Spherical Mercator Projection comme l'un des Maps API v2 utilise en interne. Si vous avez seulement besoin de longitude décalage qui ne devrait pas être difficile. Si vos utilisateurs peuvent changer le roulement et vous ne voulez pas de le remettre à 0 lors d'un zoom, vous avez besoin de latitude décalage trop et ce sera probablement un peu plus complexe à mettre en œuvre.

Je pense aussi qu'il serait bon d'avoir des Maps API v2 fonctionnalités où vous pouvez obtenir de projection pour tout CameraPosition et pas seulement de courant de sorte que vous pouvez soumettre une demande de fonctionnalité ici: http://code.google.com/p/gmaps-api-issues/issues/list?can=2&q=apitype=Android2. Vous pourrez facilement l'utiliser dans votre code pour l'effet que vous voulez.

J'ai presque exactement le même problème que vous (seulement mon décalage est à la verticale), et j'ai essayé une solution qui n'a pas fonctionné comme prévu, mais pourrait aider à vous (nous) de trouver une meilleure solution.

Ce que j'ai fait était de déplacer la caméra de la carte pour obtenir la projection sur la cible, et d'appliquer le décalage là.

J'ai placé le code dans une classe Utils et il ressemble à ceci:

public static CameraBuilder moveUsingProjection(GoogleMap map, CameraBuilder target, int verticalMapOffset) {
CameraPosition oldPosition = map.getCameraPosition();
map.moveCamera(target.build(map));
CameraBuilder result = CameraBuilder.builder()
.target(moveUsingProjection(map.getProjection(), map.getCameraPosition().target, verticalMapOffset))
.zoom(map.getCameraPosition().zoom).tilt(map.getCameraPosition().tilt);
map.moveCamera(CameraUpdateFactory.newCameraPosition(oldPosition));
return result;
}
public static LatLng moveUsingProjection(Projection projection, LatLng latLng, int verticalMapOffset) {
Point screenPoint = projection.toScreenLocation(latLng);
screenPoint.y -= verticalMapOffset;
return projection.fromScreenLocation(screenPoint);
}

Alors vous pouvez utiliser les CameraBuilder renvoyées par ces méthodes, pour l'animation, au lieu de l'original (pas offseted) de la cible.

Il fonctionne (plus ou moins), mais il a deux gros problèmes:

• La carte scintille parfois (c'est le plus gros problème, parce qu'il fait le hack inutilisable)
• C'est un hack qui peut fonctionner aujourd'hui et ne peuvent pas travailler demain (je sais pour un fait que ce même algorithme fonctionne sur iOS, par exemple).

Donc je n'ai pas aller pour cela, mais ça m'a fait penser à une alternative: Si vous aviez un nombre identique de la carte, mais caché, vous pouvez utiliser cette carte pour les calculs, puis utiliser le résultat final sur le visible de la carte.

Je pense que cette solution serait de travailler, mais c'est horrible, car vous aurez besoin de mantain deux cartes identiques, avec le traitement qui va avec, pour vous et pour l'appareil.

Comme je l'ai dit, je n'ai pas de solution définitive, mais peut-être que cela aide un peu.

J'espère que cela aide!

J'avais affaire à la même tâche et s'est terminée avec la même solution que votre dernière option :

La modification de l'emplacement d'un écran de x/y par la différence de niveau de zoom au carré. Théoriquement, cela devrait fonctionner, mais c'est toujours par un peu (~.1 latitude/longitude, ce qui est suffisant pour être loin).

Mais au lieu de point de division de l'offset sur 2<<zoomDifference je suis de calcul de la compensation de différences entre la longitude et la latitude des valeurs. Ils sont doubles, donc il me donne une assez bonne précision. Donc, essayez de convertir vos crédits à la lat/lng pas votre emplacement de pixels et l'viens de faire le même calcul.

Édité

Enfin j'ai réussi à le résoudre d'une autre manière (plus approprié, comme je le crois). Map API v2 a rembourrage paramètres. Juste de la configuration à faire de la caméra à prendre toutes pas partie cachée de MapView. L'appareil serait reflètent le centre du collier de la région après animateCamera()