Java IndoorAtlas Android SDK 1.4.2-132：全屏获取平面图图像/位图+；旋转

显然，我是Java的新手，下面是我的故事： 我一直在与Indoratalas（提供室内定位解决方案的公司）合作，Android SDK 1.4.2-132，在我的手机上测试应用程序时，我没有得到想要的结果。 这是我的完整JAVA代码，我主要从这个链接“”获得：

导入android.app.Activity；
导入android.graphics.Bitmap；
导入android.graphics.BitmapFactory；
导入android.graphics.PointF；
导入android.os.Bundle；
导入android.util.Log；
导入android.widget.ImageView；
导入com.indoratalas.android.CalibrationState；
导入com.indoratalas.android.FloorPlan；
导入com.indooratlas.android.futuresult；
导入com.indooratlas.android.ImagePoint；
导入com.indooratlas.android.indooratlas；
导入com.indooratlas.android.IndoorAtlasException；
导入com.indooratlas.android.IndoorAtlasFactory；
导入com.indooratlas.android.ResultCallback；
导入com.indooratlas.android.ServiceState；
导入com.indooratlas.android.IndoorAtlasListener；
导入java.io.IOException；
公共类FloorPlanLoader扩展活动实现IndoorAtlasListener
{
私人印度教；
private FloorPlan FloorPlan；//这里表示从未分配私有字段“FloorPlan”。
private FloorPlan mFloorPlan；//这里表示已分配私有字段“mFloorPlan”，但从未访问过。
私人影像视图；
字符串venueId=“xxx”；
字符串floorrid=“xxx”；
字符串floorPlanId=“xxx”；
字符串apiKey=“xxx”；
字符串apiSecret=“xxx”；
@凌驾
创建时的公共void（Bundle savedInstanceState）
{
super.onCreate（savedInstanceState）；
setContentView（右布局、室内定位）；
initIndoorAtlas（）；
}
public void initIndoorAtlas（）//初始化indooratlas实例的方法
{
尝试
{
ia=indoratalasfactory.createIndoratalas（getApplicationContext（），this，apiKey，apiSecret）；
}
渔获物（IndooralasEx）
{
Log.e（“Indoratalas”，“初始化失败”，ex）；
log（）；
}
FutureResult=ia.fetchFloorPlan（floorPlanId）；//获取楼层平面的实例
result.setCallback（新的ResultCallback（）{
@凌驾
公共空间结果（最终平面图结果）{
mFloorPlan=结果；
loadFloorPlanImage（结果）；
}
@凌驾
系统错误上的公共无效（IOE例外）{
}
@凌驾
申请者的公开无效（印度除外）{
}
});
}
public void loadfloorplan image（FloorPlan FloorPlan）//从服务器加载平面图的方法
{
BitmapFactory.Options=createBitmapOptions（floorPlan）；
FutureResult=ia.fetchFloorPlanImage（floorPlan，选项）；
result.setCallback（新的ResultCallback（）
{
@凌驾
public void onResult（最终位图结果）
{
runOnUiThread（新的Runnable（）
{
@凌驾
公开募捐{
imageView=（imageView）findViewById（R.id.imageView）；
设置图像位图（结果）；
}
});
updateImageViewInUiThread（）；
}
@凌驾
系统错误上的公共无效（IOE例外）
{
log（）；
}
@凌驾
申请者的公开无效（印度除外）
{
log（）；
}
});
尝试
{
ia.起始位置（venueId、FloorGrid、floorPlanId）；
}
渔获物（吲哚乙酸）
{
log（）；
}
}
私有位图工厂。选项创建位图选项（FloorPlan FloorPlan）
{
BitmapFactory.Options=new-BitmapFactory.Options（）；
内部需求宽度=2048；
内部需求高度=2048；
最终内部宽度=（内部）平面图尺寸[0]；
最终内部高度=（内部）平面图尺寸[1]；
int inSampleSize=1；
如果（高度>要求高度| |宽度>要求宽度）{
最终int半高=高度/2；
最终整数半宽度=宽度/2；
而（（半高/采样）大于所需高度
&&（半宽/采样尺寸）>reqWidth）{
inSampleSize*=2；
}
}
options.inSampleSize=inSampleSize；
返回选项；
}
public void updateImageViewInUiThread（）{}
public void onServiceUpdate（ServiceState）//显示蓝点的方法
{
int i=state.getImagePoint（）.getI（）；
int j=state.getImagePoint（）.getJ（）；
setImagePoint（state.getImagePoint（））；
PointF scaledPoint=新的PointF（）；
Util.calculateScaledPoint（（int）floorPlan.dimensions[0]，（int）floorPlan.dimensions[1]，i，j，imageView，scaledPoint）；
DrawNewPositionInUnitRead（）；
}
专用无效设置图像点（最终图像点imgPt）{
runOnUiThread（新的Runnable（）{
@凌驾
公开募捐{
ImageView imagePoint=（ImageView）findViewById（R.id.bluedottwo）；
setX（imgPt.getI（））；
setY（imgPt.getJ（））；
}
});
}
私有void drawNewPositionInUiThread（）文件{
}
公共静态类Util{
公共静态浮点计算比例因子（int originalWidth、int originalHeight、，
图像视图（图像视图）{
if（imageView.getScaleType（）！=imageView.ScaleType.CENTER\u内部）{
抛出新的IllegalArgumentException（“仅支持中心的缩放类型，为：”
import android.app.Activity;
import android.graphics.Bitmap;
import android.graphics.BitmapFactory;
import android.graphics.PointF;
import android.os.Bundle;
import android.util.Log;
import android.widget.ImageView;

import com.indooratlas.android.CalibrationState;
import com.indooratlas.android.FloorPlan;
import com.indooratlas.android.FutureResult;
import com.indooratlas.android.ImagePoint;
import com.indooratlas.android.IndoorAtlas;
import com.indooratlas.android.IndoorAtlasException;
import com.indooratlas.android.IndoorAtlasFactory;
import com.indooratlas.android.ResultCallback;
import com.indooratlas.android.ServiceState;
import com.indooratlas.android.IndoorAtlasListener;

import java.io.IOException;

public class FloorPlanLoader extends Activity implements IndoorAtlasListener
{
    private IndoorAtlas ia;
    private FloorPlan floorPlan; //here it says private field "floorplan" is never assigned.
    private FloorPlan mFloorPlan; // here it says private field "mFloorPlan" is assigned but never accessed.
    private ImageView imageView;

    String venueId = "xxx";
    String floorId = "xxx";
    String floorPlanId = "xxx";
    String apiKey = "xxx";
    String apiSecret = "xxx";

    @Override
    public void onCreate(Bundle savedInstanceState)
    {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.indoor_positioning);
        initIndoorAtlas();
    }
    public void initIndoorAtlas() //method to initialize indooratlas instance
    {
        try
        {
            ia = IndoorAtlasFactory.createIndoorAtlas(getApplicationContext(), this, apiKey, apiSecret);
        }
        catch (IndoorAtlasException ex)
        {
            Log.e("IndoorAtlas", "initialisation failed", ex);
            log();
        }
        FutureResult<FloorPlan> result = ia.fetchFloorPlan(floorPlanId); //obtains instance of floor plan
        result.setCallback(new ResultCallback<FloorPlan>() {
            @Override
            public void onResult(final FloorPlan result) {
                mFloorPlan = result;
                loadFloorPlanImage(result);
            }

            @Override
            public void onSystemError(IOException e) {

            }

            @Override
            public void onApplicationError(IndoorAtlasException e) {

            }
        });
    }
    public void loadFloorPlanImage(FloorPlan floorPlan)  //Method to load floor plan from the server
    {
        BitmapFactory.Options options = createBitmapOptions(floorPlan);
        FutureResult<Bitmap> result= ia.fetchFloorPlanImage(floorPlan, options);
        result.setCallback(new ResultCallback<Bitmap>()
        {
            @Override
            public void onResult(final Bitmap result)
            {
                runOnUiThread(new Runnable()
                {
                    @Override
                    public void run() {

                        imageView = (ImageView) findViewById(R.id.imageView);
                        imageView.setImageBitmap(result);
                    }
                });
                updateImageViewInUiThread();
            }

            @Override
            public void onSystemError(IOException e)
            {
                log();
            }

            @Override
            public void onApplicationError(IndoorAtlasException e)
            {
                log();
            }
        });
        try
        {
            ia.startPositioning(venueId, floorId, floorPlanId);
        }
        catch (IndoorAtlasException e)
        {
            log();
        }
    }

   private BitmapFactory.Options createBitmapOptions(FloorPlan floorPlan)
   {
       BitmapFactory.Options options = new BitmapFactory.Options();
       int reqWidth = 2048;
       int reqHeight = 2048;

       final int width = (int) floorPlan.dimensions[0];
       final int height = (int) floorPlan.dimensions[1];
       int inSampleSize = 1;

       if (height > reqHeight || width > reqWidth) {

           final int halfHeight = height / 2;
           final int halfWidth = width / 2;

           while ((halfHeight / inSampleSize) > reqHeight
                   && (halfWidth / inSampleSize) > reqWidth) {
               inSampleSize *= 2;
           }

       }
       options.inSampleSize = inSampleSize;
       return options;
   }

    public void updateImageViewInUiThread() {}

    public void onServiceUpdate(ServiceState state) //method to show blue dot
    {
        int i = state.getImagePoint().getI();
        int j = state.getImagePoint().getJ();
        setImagePoint(state.getImagePoint());
        PointF scaledPoint = new PointF();
        Util.calculateScaledPoint((int) floorPlan.dimensions[0], (int) floorPlan.dimensions[1], i, j, imageView, scaledPoint);
        drawNewPositionInUiThread();
    }

    private void setImagePoint(final ImagePoint imgPt) {

        runOnUiThread(new Runnable() {
            @Override
            public void run() {
                ImageView imagePoint = (ImageView) findViewById(R.id.bluedottwo);
                imagePoint.setX(imgPt.getI());
                imagePoint.setY(imgPt.getJ());
            }
        });
    }

    private void drawNewPositionInUiThread() {

    }
    public static class Util {
        public static float calculateScaleFactor(int originalWidth, int originalHeight,
                                                 ImageView imageView) {
            if (imageView.getScaleType() != ImageView.ScaleType.CENTER_INSIDE) {
                throw new IllegalArgumentException("only scale type of CENTER_INSIDE supported, was: "
                        + imageView.getScaleType());
            }

            final int availableX = imageView.getWidth()
                    - (imageView.getPaddingLeft() + imageView.getPaddingRight());
            final int availableY = imageView.getHeight()
                    - (imageView.getPaddingTop() + imageView.getPaddingBottom());

            if (originalWidth > availableX || originalHeight > availableY) {
                // original image would not fit without scaling
                return originalWidth > availableX
                        ? availableX / (float) originalWidth
                        : availableY / (float) originalHeight;
            } else {
                return 1f; // no scaling required
            }

        }
        public static void calculateScaledPoint(int originalWidth, int originalHeight,
                                                int x, int y,
                                                ImageView imageView,
                                                PointF point) {


            final float scale = calculateScaleFactor(originalWidth, originalHeight, imageView);
            final float scaledWidth = originalWidth * scale;
            final float scaledHeight = originalHeight * scale;

            // when image inside view is smaller than the view itself and image is centered (assumption)
            // there will be some empty space around the image (here offset)
            final float offsetX = Math.max(0, (imageView.getWidth() - scaledWidth) / 2);
            final float offsetY = Math.max(0, (imageView.getHeight() - scaledHeight) / 2);

            point.x = offsetX + (x * scale);
            point.y = offsetY + (y * scale);
        }
    }

    public void onServiceFailure(int errorCode, String reason)
    {
        log();
    }

    @Override
    public void onServiceInitializing()
    {
        log();
    }

    @Override
    public void onServiceInitialized()
    {
        log();
    }

    @Override
    public void onInitializationFailed(final String reason)
    {
        log();
    }

    @Override
    public void onServiceStopped()
    {
        log();
    }

    @Override
    public void onCalibrationStatus(CalibrationState calibrationState)
    {
        log();
    }

    @Override
    public void onCalibrationReady()
    {
        log();
    }

    @Override
    public void onNetworkChangeComplete(boolean success)
    {
    }

    @Override
    public void onCalibrationInvalid()
    {
    }

    @Override
    public void onCalibrationFailed(String reason)
    {
    }
    private void log()
    {
        runOnUiThread(new Runnable()
        {
            @Override
            public void run()
            {

            }
        });
    }

}

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:orientation="vertical" android:layout_width="wrap_content"
    android:layout_height="wrap_content"
    android:weightSum="1">

    <ImageView
        android:id="@+id/imageView"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:contentDescription="@string/idk"
        android:scaleType="fitCenter" />
    <ImageView
        android:id="@+id/bluedottwo"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:src="@drawable/bluedottwo"
        android:contentDescription="@string/bd"/>-->

</LinearLayout>

x = 1024(originalX) * 0.5(scale) => 512
y = 1024(orginalY) * 0.5(scale) => 512