Android 在地图视图上平滑设置摄影机路径动画

我将MapView（新API v2）与属于管线的点列表一起使用。他们靠得很近。我的问题是，如果我执行动画步骤调用

        mMapInstance.animateCamera(CameraUpdateFactory.newLatLng(mNextPosition),ms, null);

摄影师表现得像一只无畏的蚱蜢，夸张地来回移动，在这个过程中，所有的幻灯片缓存都会被捕获

设置路径动画并获得统一滚动体验的最佳方法是什么？速度不是问题，我会用低速，我对平滑感兴趣

如果我能用手指模拟一条路径，我会非常高兴。。因为地图表现得很漂亮，而且周围有很多分片。但任何以编程方式移动地图的尝试都会导致粗体动画、白色屏幕、重新加载瓷砖

---

提前感谢

好吧，我希望有人能提供一个更好的答案，但由于我做了很多实验，我无法使用animateCamera获得一个像样的平滑卷轴

尽管只改变了近距离点的Lat/Lng，摄影师还是不断进行令人印象深刻的起飞和降落

我在《el cheapo》动画中取得了有限的成功，主要表现在以下几点：

    private void animateTo(double lat, double lon, double zoom, double bearing, double tilt, final int milliseconds) {

        if (mMapInstance==null) return;
        mMapInstance.setMapType(paramMapMode);
        mCurrentPosition=new LatLng(lat,lon);

        // animate camera jumps too much
        // so we set the camera instantly to the next point

        mMapInstance.moveCamera(CameraUpdateFactory.newCameraPosition(new CameraPosition(mCurrentPosition,(float)zoom, (float)tilt, (float)bearing)));

        // give Android a break so it can load tiles. If I start the animation
        // without pause, no tile loading is done

        mMap.postDelayed(new Runnable(){
            @Override
            public void run() {
                // keeping numbers small you get a nice scrolling effect
                mMapInstance.animateCamera(CameraUpdateFactory.scrollBy(250-(float)Math.random()*500-250, 250-(float)Math.random()*500),milliseconds,null);

            }},500);

    }

该例程以10000s中的毫秒值调用，到达一个点，然后沿随机方向制作一个天桥动画，保持该死的缩放平静。由于像素值非常小，很可能是 缓存所有内容

---

有谁有更好的解决方案吗？尝试注入触摸事件来模拟“触摸”放纵是否合理或可能？

我发现使用可选回调作为最终参数来显示递归解决方案可以提供平滑的动画。此代码放大，更改全景旋转的角度，然后再次放大；但是，当初始参数和初始回调相同时，它不喜欢它；我相信有更好的方法调用递归，但希望这能让您了解如何在功能上设置动画：

    //initial zoom
static final int initZoom = 8;
//steps the zoom
int stepZoom = 0;
// number of steps in zoom, be careful with this number!
int stepZoomMax = 5;
//number of .zoom steps in a step
int stepZoomDetent = (18 - initZoom) / stepZoomMax;
//when topause zoom for spin
int stepToSpin = 4;
//steps the spin
int stepSpin = 0;
//number of steps in spin (factor of 360)
int stepSpinMax = 4;
//number of degrees in stepSpin
int stepSpinDetent = 360 / stepSpinMax;

Intent detailIntent;
Intent intent;  
Marker marker;
final int mapHopDelay = 2000;

@Override
public void onCreate(Bundle savedInstanceState)
{
    super.onCreate(savedInstanceState);
    setContentView(R.layout.map_affirm);
    try
    {MapsInitializer.initialize(this);}
    catch (GooglePlayServicesNotAvailableException impossible)
    {   /* Impossible */ Log.e(TAG, "the impossible occurred");}
    intent = this.getIntent();
    latLng = new LatLng(intent.getDoubleExtra("Latitude", 0.0), intent.getDoubleExtra("Longitude", 0.0));
    map = ((MapFragment) getFragmentManager().findFragmentById(R.id.map)).getMap();
    map.animateCamera(CameraUpdateFactory.newCameraPosition(CameraPosition.builder()
                                                            .target(latLng)
                                                            .zoom(initZoom-1)
                                                            .build())
                      , mapHopDelay
                      , cameraAnimation
                      );
    marker = map.addMarker(new MarkerOptions()
                           .draggable(true)
                           .position(latLng)
                           .title("Location of Photographer"));

}

public CancelableCallback cameraAnimation = new CancelableCallback(){

    @Override
    public void onFinish()
    {
        if (stepZoom < stepZoomMax && stepZoom != stepToSpin)
        {
            stepZoom++;
            map.animateCamera(CameraUpdateFactory.newCameraPosition(CameraPosition.builder()
                                                                    .target(latLng)
                                                                    .zoom(initZoom + (stepZoomDetent * (stepZoom - 1)))
                                                                    //   .bearing(40*aniStep)
                                                                    //   .tilt(60)
                                                                    .build()), mapHopDelay, cameraAnimation);

        }
        else if (stepZoom >= stepZoomMax)// ending position hard coded for this application
        {map.animateCamera(CameraUpdateFactory.newCameraPosition(CameraPosition.builder()
                                                                 .target(latLng)
                                                                 .zoom(18)
                                                                 //  .bearing(0)
                                                                 .tilt(0)
                                                                 .build()));
        }
        else
        {
            if (stepSpin <= stepSpinMax)
            {
                stepSpin++;
                map.animateCamera(CameraUpdateFactory.newCameraPosition(CameraPosition.builder()
                                                                        .target(latLng)
                                                                        .zoom(initZoom + stepZoomDetent * stepZoom)
                                                                        .bearing(stepSpinDetent * (stepSpin - 1))
                                                                        .tilt(60)
                                                                        .build()), mapHopDelay, cameraAnimation);
            }
            else
            {
                stepZoom++;
                map.animateCamera(CameraUpdateFactory.newCameraPosition(CameraPosition.builder()
                                                                        .target(latLng)
                                                                        .zoom(initZoom + stepZoomDetent * stepZoom)
                                                                        .bearing(0)
                                                                        .tilt(0)
                                                                        .build()), mapHopDelay, cameraAnimation);
            }
        }
    }

    @Override
    public void onCancel()
    {}

};

//初始缩放
静态最终int initZoom=8；
//步进缩放
int-stepZoom=0；
//缩放的步数，注意这个数字！
int-stepZoomMax=5；
//一个步骤中的.zoom步骤数
int-stepZoomDetent=（18-initZoom）/stepZoomMax；
//何时启动旋转缩放
int-stepToSpin=4；
//开始旋转
int-stepSpin=0；
//旋转中的步数（系数360）
int-stepSpinMax=4；
//步进旋转中的度数
int STEPSPINCATBOT=360/stepSpinMax；
意图；意图；
意图；
标记；
最终int mapHopDelay=2000；
@凌驾
创建时的公共void（Bundle savedInstanceState）
{
super.onCreate（savedInstanceState）；
setContentView（R.layout.map_）；
尝试
{MapsInitializer.initialize（this）；}
捕获（GooglePlayServicesNotAvailableException不可能）
{/*不可能*/Log.e（标记“不可能发生”）；}
intent=this.getIntent（）；
latLng=新latLng（intent.getDoubleExtra（“纬度”，0.0），intent.getDoubleExtra（“经度”，0.0））；
map=（（MapFragment）getFragmentManager（）.findFragmentById（R.id.map））.getMap（）；
map.animateCamera（CameraUpdateFactory.newCameraPosition（CameraPosition.builder）（）
.目标（latLng）
.zoom（initZoom-1）
.build（））
，mapHopDelay
，摄影及动画
);
marker=map.addMarker（新的MarkerOptions（）
.draggable（真）
.位置（车床）
.标题（“摄影师的位置”）；
}
public CancelableCallback cameraAnimation=新建CancelableCallback（）{
@凌驾
公共无效onFinish（）
{
如果（stepZoom=stepZoomMax）//为此应用程序硬编码的结束位置
{map.animateCamera（CameraUpdateFactory.newCameraPosition（CameraPosition.builder（））
.目标（latLng）
.zoom（18）
//.轴承（0）
.倾斜（0）
.build（））；
}
其他的
{
如果（stepSpin hi！听起来很有趣，我还没有使用回调，我将尝试一下。感谢您发布代码！您不能在mMap上调用
postDelayed（）
！