ArcGIS for Android xxx.geodatabase 操作简介(100.3.0)

破z晓

已于 2023-03-30 11:23:31 修改

阅读量2.2k

点赞数 3

文章标签： android java apache

于 2020-04-15 15:48:10 首次发布

本文链接：https://blog.csdn.net/qq_19688207/article/details/105535543

版权

xxx.geodatabase可以理解为一个空间数据库

直接上代码：

1. 下载GDB

/** 数据保存路径--（“/gdb”是文件夹）*/
String gdbFile = context.getCacheDir().getParent() + "/gdb";
/**调用判断文件夹是否存在方法*/
localPath(gdbFile);
/**gdb文件位置(包含文件名)*/
this.localGeodatabasePath = gdbFile+"/pipeline.geodatabase";



 /**判断文件夹是否存在，不存在则新建*/
    private void localPath(String path){
        File file = new File(path);
        if (!file.exists()) {
            file.mkdirs();
        }
    }



    /**
     * 下载gdb数据并加载到地图上
     */
    public void downloadGeodatabase() {
        mGeodatabaseSyncTask = new GeodatabaseSyncTask(serverPath);
        mGeodatabaseSyncTask.loadAsync();
        mGeodatabaseSyncTask.addDoneLoadingListener(new Runnable() {
            @Override
            public void run() {
                // 显示用作图形的范围
                final Envelope extent = mMapView.getVisibleArea().getExtent();
                // 为当前范围创建生成地理数据库参数
                final ListenableFuture<GenerateGeodatabaseParameters> defaultParameters = mGeodatabaseSyncTask
                        .createDefaultGenerateGeodatabaseParametersAsync(extent);
                defaultParameters.addDoneListener(new Runnable() {
                    @Override
                    public void run() {
                        try {
                            // 设置参数，不包括附件
                            GenerateGeodatabaseParameters parameters = defaultParameters.get();
                            parameters.setReturnAttachments(false);
                            // 创建工程
                            final GenerateGeodatabaseJob generateGeodatabaseJob = mGeodatabaseSyncTask
                                    .generateGeodatabaseAsync(parameters, localGeodatabasePath);
                            generateGeodatabaseJob.start();
                            createProgressDialog(generateGeodatabaseJob, "下载GDB数据");
                            // 获取GDB数据文件
                            generateGeodatabaseJob.addJobDoneListener(new Runnable() {
                                @Override
                                public void run() {
                                    if (generateGeodatabaseJob.getStatus() == Job.Status.SUCCEEDED) {
                                        mGeodatabase = generateGeodatabaseJob.getResult();
                                        mGeodatabase.loadAsync();
                                        mGeodatabase.addDoneLoadingListener(new Runnable() {
                                            @Override
                                            public void run() {
                                                if (mGeodatabase.getLoadStatus() == LoadStatus.LOADED) {
                                                    // 将gdb图层加载到地图上
                                                   /* List<GeodatabaseFeatureTable> gdbList = mGeodatabase.getGeodatabaseFeatureTables();
                                                    for (int i=0; i<gdbList.size(); i++){
                                                        GeodatabaseFeatureTable gdbFeatureTable = gdbList.get(i);
                                                        gdbFeatureTable.loadAsync();// 异步加载（必须写）
                                                        FeatureLayer featureLayer = new FeatureLayer(gdbFeatureTable);
                                                        // 加载 geodatabase 数据图层
                                                        mMapView.getMap().getOperationalLayers().add(featureLayer);
                                                    }*/

                                                } else {
                                                    Toast.makeText(context,
                                                            "加载失败！", Toast.LENGTH_LONG).show();
                                                }
                                            }
                                        });
                                    } else if (generateGeodatabaseJob.getError() != null) {

                                        Toast.makeText(context,
                                                "Error generating geodatabase: " + generateGeodatabaseJob.getError().getMessage(),
                                                Toast.LENGTH_LONG).show();
                                    } else {
                                        Toast.makeText(context, "Unknown Error generating geodatabase", Toast.LENGTH_LONG).show();
                                    }
                                }
                            });
                        } catch (InterruptedException | ExecutionException e) {

                            Toast.makeText(context, "Error generating geodatabase parameters: " + e.getMessage(),
                                    Toast.LENGTH_LONG).show();
                        }
                    }
                });
            }
        });
    }

2.同步GDB

 /**
     * 同步gdb数据
     */
    public void syncGeodatabase() {
        if (mGeodatabase != null){
            // 创建同步参数
            final SyncGeodatabaseParameters syncGeodatabaseParameters = new SyncGeodatabaseParameters();
            syncGeodatabaseParameters.setSyncDirection(SyncGeodatabaseParameters.SyncDirection.BIDIRECTIONAL);
            syncGeodatabaseParameters.setRollbackOnFailure(false);
            // 获取地理数据库中每个特性表的层ID，然后将其添加到同步作业中
            for (GeodatabaseFeatureTable geodatabaseFeatureTable : mGeodatabase.getGeodatabaseFeatureTables()) {
                long serviceLayerId = geodatabaseFeatureTable.getServiceLayerId();
                SyncLayerOption syncLayerOption = new SyncLayerOption(serviceLayerId);
                syncGeodatabaseParameters.getLayerOptions().add(syncLayerOption);
            }

            mGeodatabaseSyncTask = new GeodatabaseSyncTask(serverPath);
            mGeodatabase.addDoneLoadingListener(new Runnable() {
                @Override
                public void run() {
                    final SyncGeodatabaseJob syncGeodatabaseJob = mGeodatabaseSyncTask
                            .syncGeodatabaseAsync(syncGeodatabaseParameters, mGeodatabase);
                    syncGeodatabaseJob.start();

                    createProgressDialog(syncGeodatabaseJob, "同步GDB数据");

                    syncGeodatabaseJob.addJobDoneListener(new Runnable() {
                        @Override
                        public void run() {
                            if (syncGeodatabaseJob.getStatus() == Job.Status.SUCCEEDED) {
                                Toast.makeText(context, "同步成功", Toast.LENGTH_SHORT).show();
                            } else {
                                Toast.makeText(context, "数据库没有正确同步", Toast.LENGTH_LONG).show();
                            }
                        }
                    });
                }
            });
        }else {
            Toast.makeText(context, "本地无数据",Toast.LENGTH_SHORT).show();
        }
    }


    /**
     * 进度条
     */
    private void createProgressDialog(final Job job, String title) {

        final ProgressDialog syncProgressDialog = new ProgressDialog(context);
        syncProgressDialog.setTitle(title);
        syncProgressDialog.setProgressStyle(ProgressDialog.STYLE_HORIZONTAL);
        syncProgressDialog.setCanceledOnTouchOutside(false);
        syncProgressDialog.show();
        // 监听下载进度
        job.addProgressChangedListener(new Runnable() {
            @Override
            public void run() {
                syncProgressDialog.setProgress(job.getProgress());
                if (job.getProgress() == 100)
                    syncProgressDialog.dismiss();// 当值为100取消显示dialog
            }
        });

    }

3.从GDB数据库中查询属性信息

        // final String whereClause = "name = "+ "\""+qujie_name+"\"";
        // 查询语句
        final String whereClause = "name  like "+ "\'%"+name+"%\'";
        QueryParameters query = new QueryParameters();
        query.setWhereClause(whereClause);
        if (name.length() != 0){
            for (GeodatabaseFeatureTable gdbTable : gdbFeatureTables){
                final FeatureLayer queryFeatureLayer = gdbTable.getFeatureLayer();
                // 查询图层显示
                queryFeatureLayer.setVisible(false);
                final ListenableFuture<FeatureQueryResult> featureQueryResult = queryFeatureLayer.selectFeaturesAsync(query,FeatureLayer.SelectionMode.SUBTRACT);
                featureQueryResult.addDoneListener(new Runnable() {
                    @Override
                    public void run() {
                        try {
                            FeatureQueryResult features = featureQueryResult.get();
                            for (Object element : features){
                                if (element instanceof Feature){
                                    mFeature = (Feature) element;
                                    // 查询图层显示
                                    queryFeatureLayer.setVisible(true);
                                    // 筛选要素图层
                                    queryFeatureLayer.setDefinitionExpression(whereClause);
                                    // 高亮
                                    queryFeatureLayer.selectFeature(mFeature);
                                    // 取消高亮
                                    queryFeatureLayer.unselectFeature(mFeature);

                                    Geometry geometry = mFeature.getGeometry();
                                    // 点 定位 - 固定比例尺
                                    // mapView.setViewpointCenterAsync((Point) geometry,500);
                                    // 图形定位 - 自定义比例尺
                                    mapView.setViewpointGeometryAsync(geometry);
                                      /* Graphic graphic = null;
                                       if (geometry.getGeometryType() == GeometryType.POINT){// 点
                                           Point point = (Point) geometry;
                                            SimpleMarkerSymbol simpleMarkerSymbol = new SimpleMarkerSymbol(SimpleMarkerSymbol.Style.CIRCLE,Color.RED,8);
                                           // 渲染
                                           SimpleRenderer simpleRenderer = new SimpleRenderer(simpleMarkerSymbol);
                                           mGraphicsOverlay.setRenderer(simpleRenderer);
                                           graphic = new Graphic(point);
                                           mGraphicsOverlay.getGraphics().add(graphic);
                                       }else if(geometry.getGeometryType() == GeometryType.POLYLINE){// 线
                                           Polyline polyline = (Polyline) geometry;
                                           SimpleLineSymbol simpleLineSymbol = new SimpleLineSymbol(SimpleLineSymbol.Style.SOLID,Color.GREEN,2);
                                           graphic = new Graphic(polyline,simpleLineSymbol);
                                           mGraphicsOverlay.getGraphics().add(graphic);

                                       }else if (geometry.getGeometryType() == GeometryType.POLYGON){// 面
                                            Polygon polygon = (Polygon) geometry;
                                           SimpleLineSymbol simpleLineSymbol = new SimpleLineSymbol(SimpleLineSymbol.Style.SOLID,Color.BLUE,2);
                                           graphic = new Graphic(polygon,simpleLineSymbol);
                                           mGraphicsOverlay.getGraphics().add(graphic);
                                       }*/
                                }
                            }


                        }catch (Exception ex){
                            ex.printStackTrace();
                        }
                    }
                });

            }

        }

4.添加信息和空间信息到GDB

featureTable.addFeatureAsync(feature) --- 添加方法

 GeodatabaseFeatureTable layer = gdbFeatureTables.get(0);
        final FeatureLayer featureLayer = layer.getFeatureLayer();
        featureLayer.addDoneLoadingListener(new Runnable() {
            @Override
            public void run() {
                FeatureTable featureTable = featureLayer.getFeatureTable();
                // 判断当前featureTable图层是否可编辑\可否添加信息
                if (featureTable.isEditable() && featureTable.canAdd()){
                    Feature feature = featureTable.createFeature();
                    // 添加信息到GDB
                    /**feature.getAttributes().put(属性值, 添加内容);**/
                    feature.getAttributes().put("name", "test");
        
                    // 添加空间对象(点线面均可以)
                    /** feature.setGeometry(Geometry);**/
                    feature.setGeometry(point);

                    // 调用addFeatureAsync方法增加要素
                    final ListenableFuture<Void> addFeatureOper = featureTable.addFeatureAsync(feature);
                    addFeatureOper.addDoneListener(new Runnable() {
                        @Override
                        public void run() {
                            try {
                                addFeatureOper.get();
                                if (addFeatureOper.isDone()) {
                                    // 定位到添加点
                                    Point point = new Point(Double.parseDouble((String) map.get("point_x")), Double.parseDouble((String) map.get("point_y")));
                                    setMapCenter(point);
                                    //Toast.makeText(context, "success", Toast.LENGTH_SHORT).show();
                                }
                            } catch (InterruptedException interruptedExceptionException) {
                                // 处理异常
                                Toast.makeText(context, "fail", Toast.LENGTH_SHORT).show();
                            } catch (ExecutionException executionException) {
                                // 处理异常
                                Toast.makeText(context, "fail", Toast.LENGTH_SHORT).show();
                            }
                        }
                    });
                } else {
                    Toast.makeText(context, "不允许添加", Toast.LENGTH_SHORT).show();
                }
            }
        });

5.删除GDB中信息和空间信息

feature.getFeatureTable().deleteFeatureAsync(feature) --- 删除方法

//  private List<Feature> mSelectedFeatures; 
public void deleteFeatureOnTap(){
        for (Feature feature : mSelectedFeatures) {
            feature.getFeatureTable().deleteFeatureAsync(feature);
        }
        mSelectedFeatures.clear();
    }

6.更改GDB中信息和空间信息

feature.getFeatureTable().updateFeatureAsync(feature); --- 更新方法

 public void updateLineToGdb(final HashMap map){
        for (final Feature feature : mSelectedFeatures) {
            final FeatureTable featureTable = feature.getFeatureTable();
            // 更新name属性数据
            feature.getAttributes().put("name", "test");
            // 更新要素
            final ListenableFuture<Void> updateFeatureOper = featureTable.updateFeatureAsync(feature);
            updateFeatureOper.addDoneListener(new Runnable() {
                @Override
                public void run() {
                    try {
                        updateFeatureOper.get();
                        if (updateFeatureOper.isDone()){
                         
                           // Toast.makeText(context, "success", Toast.LENGTH_SHORT).show();
                        }
                    } catch (ExecutionException e) {
                        // 处理异常
                        Toast.makeText(context, "fail", Toast.LENGTH_SHORT).show();
                        e.printStackTrace();
                    } catch (InterruptedException e) {
                        // 处理异常
                        Toast.makeText(context, "fail", Toast.LENGTH_SHORT).show();
                        e.printStackTrace();
                    }

                }
            });
        }
        mSelectedFeatures.clear();
    }

7.筛选图层

 for (GeodatabaseFeatureTable gdbTable : gdbFeatureTables) {
                FeatureLayer featureLayer = gdbTable.getFeatureLayer();
                // 筛选出nama 列中 值是 demo的数据并加载地图
                featureLayer.setDefinitionExpression("name = "+ "\""+demo+"\"");
               // featureLayer.setVisible(true);// 显示
                 mMapView.getMap().getOperationalLayers().add(featureLayer);
    }

8.加载本地GDB

     /**
     * 加载geodatabase数据
     * 一次性全部加载
     * */
    public void initLoadGDB(){
        if (mGeodatabase == null){
            mGeodatabase = new Geodatabase(localGeodatabasePath);
            mGeodatabase.loadAsync();// 异步加载（必须写）
            mGeodatabase.addDoneLoadingListener(new Runnable() {
                @Override
                public void run() {
                    gdbFeatureTables = mGeodatabase.getGeodatabaseFeatureTables();
                    for (GeodatabaseFeatureTable gdbTable : gdbFeatureTables) {
                        // 此方法在第一次加载gdbTable无法获取layer
                        //FeatureLayer featureLayer = gdbFeatureTable.getFeatureLayer();
                         // 此方法只能在第一次加载gdbTable时使用
                        FeatureLayer featureLayer = new FeatureLayer(gdbTable);

                        //featureLayer.setVisible(false);// 隐藏
                        mMapView.getMap().getOperationalLayers().add(featureLayer);
                    }
                }
            });
        }
    }

9.根据图层名称加载GDB图层

 /**
     * 加载GDB数据
     * @param gdbLayerName - 要加载的图层名称
     * */
    public void loadGDBFile(final String gdbLayerName){
        makeRootDirectory(context,"GDB");// 创建存储GDB数据文件夹
        mGeodatabase = new Geodatabase(readGDBFile(context,"info"));
        mGeodatabase.loadAsync();// 异步加载（必须写）
        mGeodatabase.addDoneLoadingListener(new Runnable() {
            @Override
            public void run() {
                GeodatabaseFeatureTable gdbTable = mGeodatabase.getGeodatabaseFeatureTable(gdbLayerName);
                FeatureLayer featureLayer = new FeatureLayer(gdbTable);
                mMapView.getMap().getOperationalLayers().add(featureLayer);
            }
        });
    }

破z晓

关注

3
点赞
踩
3

收藏

觉得还不错? 一键收藏
7
评论
ArcGIS for Android xxx.geodatabase 操作简介(100.3.0)

xxx.geodatabase可以理解为一个空间数据库直接上代码：1. 下载GDB/** 数据保存路径--（“/gdb”是文件夹）*/String gdbFile = context.getCacheDir().getParent() + "/gdb";/**调用判断文件夹是否存在方法*/localPath(gdbFile);/**gdb文......
复制链接

扫一扫