How to use

ArrayUtil

in

cc.blynk.utils

public void addTag(DashBoard dash, Tag newTag) {
  dash.tags = ArrayUtil.add(dash.tags, newTag, Tag.class);
}

@Override
public boolean isAssignedToDevice(int deviceId) {
  return ArrayUtil.contains(this.deviceIds, deviceId);
}

public void deleteTag(DashBoard dash, int tagId) {
  int existingTagIndex = getTagIndexByIdOrThrow(dash, tagId);
  dash.tags = ArrayUtil.remove(dash.tags, existingTagIndex, Tag.class);
}

  @Override
  public void deleteDevice(int deviceId) {
    Tile[] localTiles = this.tiles;
    int index = getTileIndexByDeviceId(localTiles, deviceId);
    if (index != -1) {
      this.tiles = localTiles.length == 1 ? EMPTY_DEVICE_TILES : ArrayUtil.remove(localTiles, index, Tile.class);
    }

    for (TileTemplate tileTemplate : this.templates) {
      tileTemplate.deviceIds = ArrayUtil.deleteFromArray(tileTemplate.deviceIds, deviceId);
    }

  }
}

public void messageReceived(ChannelHandlerContext ctx, MobileStateHolder state, StringMessage message) {
  var id = message.body;
  var user = state.user;
  var existingAppIndex = user.profile.getAppIndexById(id);
  if (existingAppIndex == -1) {
    throw new NotAllowedException("App with passed is not exists.", message.id);
  }
  var projectIds = user.profile.apps[existingAppIndex].projectIds;
  var result = new ArrayList<DashBoard>();
  for (DashBoard dash : user.profile.dashBoards) {
    if (ArrayUtil.contains(projectIds, dash.id)) {
      timerWorker.deleteTimers(state.userKey, dash);
      tokenManager.deleteDash(dash);
      sessionDao.closeHardwareChannelByDashId(state.userKey, dash.id);
    } else {
      result.add(dash);
    }
  }
  user.profile.dashBoards = result.toArray(new DashBoard[0]);
  user.profile.apps = ArrayUtil.remove(user.profile.apps, existingAppIndex, App.class);
  user.lastModifiedTs = System.currentTimeMillis();
  ctx.writeAndFlush(ok(message.id), ctx.voidPromise());
}

@Override
public boolean setProperty(WidgetProperty property, String propertyValue) {
  switch (property) {
    case OPACITY :
      this.opacity = Integer.parseInt(propertyValue);
      return true;
    case SCALE :
      this.scale = Integer.parseInt(propertyValue);
      return true;
    case ROTATION :
      this.rotation = Integer.parseInt(propertyValue);
      return true;
    case URLS :
      this.urls = propertyValue.split(StringUtils.BODY_SEPARATOR_STRING);
      return true;
    case URL :
      String[] split = StringUtils.split2(propertyValue);
      if (split.length == 2) {
        int index = Integer.parseInt(split[0]) - 1;
        if (index >= 0 && index < urls.length) {
          this.urls = ArrayUtil.copyAndReplace(this.urls, split[1], index);
          return true;
        }
      }
      return false;
    default:
      return super.setProperty(property, propertyValue);
  }
}

  @Override
  public void deleteDevice(int deviceId) {
    this.deviceIds = ArrayUtil.deleteFromArray(this.deviceIds, deviceId);
  }
}

reportingWidget.reports = ArrayUtil.copyAndReplace(reportingWidget.reports, report, existingReportIndex);
dash.updatedAt = System.currentTimeMillis();

  @Override
  public void deleteDevice(int deviceId) {
    this.deviceIds = ArrayUtil.deleteFromArray(this.deviceIds, deviceId);
  }
}

@Override
public boolean contains(int deviceId) {
  return ArrayUtil.contains(this.deviceIds, deviceId);
}

public void addDevice(DashBoard dash, Device device) {
  dash.devices = ArrayUtil.add(dash.devices, device, Device.class);
}

public Device deleteDevice(DashBoard dash, int deviceId) {
  int existingDeviceIndex = getDeviceIndexByIdOrThrow(dash, deviceId);
  Device deviceToRemove = dash.devices[existingDeviceIndex];
  dash.devices = ArrayUtil.remove(dash.devices, existingDeviceIndex, Device.class);
  dash.eraseWidgetValuesForDevice(deviceId);
  return deviceToRemove;
}

        tileTemplate.widgets, newTabs.tabs.length - 1);
  tileTemplate.widgets = ArrayUtil.copyAndReplace(
      tileTemplate.widgets, newWidget, tileTemplate.getWidgetIndexByIdOrThrow(newWidget.id));
} else {
        dash.widgets, newTabs.tabs.length - 1);
  dash.widgets = ArrayUtil.copyAndReplace(
      dash.widgets, newWidget, dash.getWidgetIndexByIdOrThrow(newWidget.id));

  @Override
  public void deleteDevice(int deviceId) {
    this.deviceIds = ArrayUtil.deleteFromArray(this.deviceIds, deviceId);
  }
}

@Override
public boolean isSelected(int deviceId) {
  return ArrayUtil.contains(deviceIds, deviceId);
}

public static void messageReceived(ChannelHandlerContext ctx, MobileStateHolder state,
                  StringMessage message, int maxWidgetSize) {
  var appString = message.body;
  if (appString == null || appString.isEmpty()) {
    throw new IllegalCommandException("Income app message is empty.");
  }
  if (appString.length() > maxWidgetSize) {
    throw new NotAllowedException("App is larger then limit.", message.id);
  }
  var newApp = JsonParser.parseApp(appString, message.id);
  newApp.id = AppNameUtil.generateAppId();
  if (newApp.isNotValid()) {
    throw new NotAllowedException("App is not valid.", message.id);
  }
  log.debug("Creating new app {}.", newApp);
  var user = state.user;
  if (user.profile.apps.length > 25) {
    throw new NotAllowedException("App limit is reached.", message.id);
  }
  for (App app : user.profile.apps) {
    if (app.id.equals(newApp.id)) {
      throw new NotAllowedException("App with same id already exists.", message.id);
    }
  }
  user.profile.apps = ArrayUtil.add(user.profile.apps, newApp, App.class);
  user.lastModifiedTs = System.currentTimeMillis();
  ctx.writeAndFlush(makeUTF8StringMessage(CREATE_APP, message.id, JsonParser.toJson(newApp)), ctx.voidPromise());
}

private static void deleteDash(Holder holder, MobileStateHolder state, int dashId) {
  User user = state.user;
  int index = user.profile.getDashIndexOrThrow(dashId);
  log.debug("Deleting dashboard {}.", dashId);
  DashBoard dash = user.profile.dashBoards[index];
  user.addEnergy(dash.energySum());
  holder.timerWorker.deleteTimers(state.userKey, dash);
  holder.tokenManager.deleteDash(dash);
  holder.sessionDao.closeHardwareChannelByDashId(state.userKey, dashId);
  holder.reportScheduler.cancelStoredFuture(user, dashId);
  holder.blockingIOProcessor.executeHistory(() -> {
    for (Device device : dash.devices) {
      try {
        holder.reportingDiskDao.delete(state.user, dashId, device.id);
      } catch (Exception e) {
        log.warn("Error removing device data. Reason : {}.", e.getMessage());
      }
    }
  });
  user.profile.dashBoards = ArrayUtil.remove(user.profile.dashBoards, index, DashBoard.class);
}

@Override
public void deleteDevice(int deviceId) {
  this.deviceIds = ArrayUtil.deleteFromArray(this.deviceIds, deviceId);
}

@Override
public boolean contains(int deviceId) {
  return ArrayUtil.contains(this.deviceIds, deviceId);
}

deviceTiles.templates = ArrayUtil.add(deviceTiles.templates, newTileTemplate, TileTemplate.class);
deviceTiles.recreateTilesIfNecessary(newTileTemplate, null);