@Override
public void createNewVectorLayer(
        final Context context,
        final LayerGroup groupLayer,
        final Uri uri)
{
    String layerName =
            FileUtil.getFileNameByUri(context, uri, context.getString(R.string.new_layer));
    final int lastPeriodPos = layerName.lastIndexOf('.');
    if (lastPeriodPos > 0) {
        layerName = layerName.substring(0, lastPeriodPos);
    }
    if (context instanceof NGActivity) {
        NGActivity fragmentActivity = (NGActivity) context;
        CreateLocalLayerDialog newFragment = new CreateLocalLayerDialog();
        newFragment.setLayerGroup(groupLayer)
                .setLayerType(LayerFillService.VECTOR_LAYER)
                .setUri(uri)
                .setLayerName(layerName)
                .setTitle(context.getString(R.string.create_vector_layer))
                .setTheme(fragmentActivity.getThemeId())
                .show(fragmentActivity.getSupportFragmentManager(), "create_vector_layer");
    }
}
 

@Override
public void createNewVectorLayerWithForm(
        final Context context,
        final LayerGroup groupLayer,
        final Uri uri)
{
    String layerName =
            FileUtil.getFileNameByUri(context, uri, context.getString(R.string.new_layer));
    final int lastPeriodPos = layerName.lastIndexOf('.');
    if (lastPeriodPos > 0) {
        layerName = layerName.substring(0, lastPeriodPos);
    }
    if (context instanceof NGActivity) {
        NGActivity fragmentActivity = (NGActivity) context;
        CreateLocalLayerDialog newFragment = new CreateLocalLayerDialog();
        newFragment.setLayerGroup(groupLayer)
                .setLayerType(LayerFillService.VECTOR_LAYER_WITH_FORM)
                .setUri(uri)
                .setLayerName(layerName)
                .setTitle(context.getString(R.string.create_vector_layer))
                .setTheme(fragmentActivity.getThemeId())
                .show(fragmentActivity.getSupportFragmentManager(), "create_vector_with_form_layer");
    }
}
 

protected void sync(
        LayerGroup layerGroup,
        String authority,
        SyncResult syncResult)
{
    for (int i = 0; i < layerGroup.getLayerCount(); i++) {
        if (isCanceled()) {
            return;
        }
        ILayer layer = layerGroup.getLayer(i);
        if (layer instanceof LayerGroup) {
            sync((LayerGroup) layer, authority, syncResult);
        } else if (layer instanceof INGWLayer) {
            INGWLayer ngwLayer = (INGWLayer) layer;
            String accountName = ngwLayer.getAccountName();
            if (!mVersions.containsKey(accountName))
                mVersions.put(accountName, NGWUtil.getNgwVersion(getContext(), accountName));

            Pair<Integer, Integer> ver = mVersions.get(accountName);
            ngwLayer.sync(authority, ver, syncResult);
        } else if (layer instanceof TrackLayer) {
            ((TrackLayer) layer).sync();
        }
    }
}
 

public List<ILayer> getLayersByType(int types)
{
    List<ILayer> ret = new ArrayList<>();

    if (mMap != null) {
        LayerGroup.getLayersByType(mMap, types, ret);
    }

    return ret;
}
 

public List<ILayer> getVectorLayersByType(int types)
{
    List<ILayer> ret = new ArrayList<>();

    if (mMap != null) {
        LayerGroup.getVectorLayersByType(mMap, types, ret);
    }

    return ret;
}
 

public void createNewNGWLayer(
        final Context context,
        final LayerGroup layerGroup)
{
    if (context instanceof NGActivity) {
        AccountManager accountManager = AccountManager.get(context);
        Connections connections = SelectNGWResourceDialog.fillConnections(context, accountManager);
        if (connections.getChildrenCount() == 1) {
            startNGWResourceActivity(context, (Connection) connections.getChild(0), layerGroup);
        } else {
            NGActivity fragmentActivity = (NGActivity) context;
            final SelectNGWResourceDialog newFragment = new SelectNGWResourceDialog();
            newFragment.setLayerGroup(layerGroup)
                    .setTypeMask(
                            Connection.NGWResourceTypePostgisLayer |
                                    Connection.NGWResourceTypeVectorLayer |
                                    Connection.NGWResourceTypeRasterLayer |
                                    Connection.NGWResourceTypeWMSClient |
                                    Connection.NGWResourceTypeWebMap)
                    .setConnectionListener(new NGWResourcesListAdapter.OnConnectionListener() {
                        @Override
                        public void onConnectionSelected(Connection connection) {
                            startNGWResourceActivity(context, connection, layerGroup);
                            newFragment.dismiss();
                        }

                        @Override
                        public void onAddConnection() {
                            newFragment.onAddAccount(context);
                        }
                    })
                    .setTitle(context.getString(R.string.choose_layers))
                    .setTheme(fragmentActivity.getThemeId())
                    .show(fragmentActivity.getSupportFragmentManager(), "create_ngw_layer");
        }
    }
}
 

private void startNGWResourceActivity(Context context, Connection connection, LayerGroup layerGroup) {
    Intent intent = new Intent(context, SelectNGWResourceActivity.class);
    Connections connections = new Connections(context.getString(R.string.ngw_accounts));
    connections.add(connection);
    intent.putExtra(SelectNGWResourceActivity.KEY_TASK, SelectNGWResourceActivity.TYPE_ADD);
    intent.putExtra(SelectNGWResourceActivity.KEY_CONNECTIONS, connections);
    intent.putExtra(SelectNGWResourceActivity.KEY_RESOURCE_ID, connections.getChild(0).getId());
    intent.putExtra(SelectNGWResourceActivity.KEY_GROUP_ID, layerGroup.getId());
    context.startActivity(intent);
}
 

public void createNewRemoteTMSLayer(
        final Context context,
        final LayerGroup groupLayer)
{
    if (context instanceof NGActivity) {
        NGActivity fragmentActivity = (NGActivity) context;
        CreateFromQMSLayerDialog newFragment = new CreateFromQMSLayerDialog();
        newFragment.setLayerGroup(groupLayer)
                .setTitle(context.getString(R.string.create_qms_layer))
                .setTheme(fragmentActivity.getThemeId())
                .show(fragmentActivity.getSupportFragmentManager(), "create_qms_layer");
    }
}
 

protected void checkTracksLayerExist()
{
    List<ILayer> tracks = new ArrayList<>();
    LayerGroup.getLayersByType(mMap, Constants.LAYERTYPE_TRACKS, tracks);
    if (tracks.isEmpty()) {
        String trackLayerName = getString(R.string.tracks);
        TrackLayerUI trackLayer =
                new TrackLayerUI(getApplicationContext(), mMap.createLayerStorage(LAYER_TRACKS));
        trackLayer.setName(trackLayerName);
        trackLayer.setVisible(true);
        mMap.addLayer(trackLayer);
        mMap.save();
    }
}
 

public CreateRemoteTMSLayerDialog setLayerGroup(LayerGroup groupLayer)
{
    mGroupLayer = groupLayer;
    return this;
}
 

public CreateLocalLayerDialog setLayerGroup(LayerGroup groupLayer)
{
    mGroupLayer = groupLayer;
    return this;
}
 

public SelectNGWResourceDialog setLayerGroup(LayerGroup groupLayer)
{
    mGroupLayer = groupLayer;
    return this;
}
 

public CreateFromQMSLayerDialog setLayerGroup(LayerGroup groupLayer) {
    mGroupLayer = groupLayer;
    return this;
}
 

@Override
public int onStartCommand(Intent intent, int flags, int startId) {
    Log.i("LayerFillService", "Received start id " + startId + ": " + intent);
    if (intent != null) {
        String action = intent.getAction();
        if (action != null && !TextUtils.isEmpty(action)) {
            switch (action) {
                case ACTION_ADD_TASK:
                    int layerGroupId = intent.getIntExtra(KEY_LAYER_GROUP_ID, Constants.NOT_FOUND);
                    mLayerGroup = (LayerGroup) MapBase.getInstance().getLayerById(layerGroupId);

                    int layerType = intent.getIntExtra(KEY_INPUT_TYPE, Constants.NOT_FOUND);
                    Bundle extra = intent.getExtras();

                    switch (layerType) {
                        case VECTOR_LAYER:
                            mQueue.add(new VectorLayerFillTask(extra));
                            break;
                        case VECTOR_LAYER_WITH_FORM:
                            mQueue.add(new UnzipForm(extra));
                            break;
                        case TMS_LAYER:
                            mQueue.add(new LocalTMSFillTask(extra));
                            break;
                        case NGW_LAYER:
                            mQueue.add(new NGWVectorLayerFillTask(extra));
                            break;
                    }

                    if(!mIsRunning){
                        startNextTask();
                    }

                    return START_STICKY;
                case ACTION_STOP:
                    mQueue.clear();
                    mIsCanceled = true;
                    startNextTask();
                    break;
                case ACTION_SHOW:
                    mProgressIntent.putExtra(KEY_STATUS, STATUS_SHOW).putExtra(KEY_TITLE, mNotifyTitle);
                    sendBroadcast(mProgressIntent);
                    break;
            }
        }
    }
    return START_STICKY;
}
 

@Override
public void createNewLocalTMSLayer(
        final Context context,
        final LayerGroup groupLayer,
        final Uri uri)
{
    String ext = "zip";
    String layerName =
            FileUtil.getFileNameByUri(context, uri, context.getString(R.string.new_layer));
    final int lastPeriodPos = layerName.lastIndexOf('.');
    if (lastPeriodPos > 0) {
        ext = layerName.substring(lastPeriodPos).toLowerCase();
        layerName = layerName.substring(0, lastPeriodPos);
    }
    if (context instanceof NGActivity) {
        NGActivity fragmentActivity = (NGActivity) context;

        if (ext.equals(".ngrc")) {
            Intent intent = new Intent(context, LayerFillService.class);
            intent.setAction(LayerFillService.ACTION_ADD_TASK);
            intent.putExtra(LayerFillService.KEY_URI, uri);
            intent.putExtra(LayerFillService.KEY_INPUT_TYPE, LayerFillService.TMS_LAYER);
            intent.putExtra(LayerFillService.KEY_LAYER_GROUP_ID, groupLayer.getId());

            LayerFillProgressDialogFragment.startFill(intent);
            return;
        }

        AtomicReference<Uri> temp = new AtomicReference<>(uri);
        if (MapUtil.isZippedGeoJSON(context, temp)) {
            createNewVectorLayer(context, groupLayer, temp.get());
            return;
        }

        CreateLocalLayerDialog newFragment = new CreateLocalLayerDialog();
        newFragment.setLayerGroup(groupLayer)
                .setLayerType(LayerFillService.TMS_LAYER)
                .setUri(uri)
                .setLayerName(layerName)
                .setTitle(context.getString(R.string.create_tms_layer))
                .setTheme(fragmentActivity.getThemeId())
                .show(fragmentActivity.getSupportFragmentManager(), "create_tms_layer");
    }
}