private void listenForCommands()

in android/src/main/java/com/facebook/flipper/plugins/databases/DatabasesManager.java [64:243]
180 lines of code
15 McCabe index (conditional complexity)

  private void listenForCommands(FlipperConnection connection) {
    connection.receive(
        DATABASE_LIST_COMMAND,
        new FlipperReceiver() {
          @Override
          public void onReceive(FlipperObject params, FlipperResponder responder) {
            int databaseId = 1;
            mDatabaseDescriptorHolderSparseArray.clear();
            mDatabaseDescriptorHolderSet.clear();
            for (DatabaseDriver<?> databaseDriver : mDatabaseDriverList) {
              List<? extends DatabaseDescriptor> databaseDescriptorList =
                  databaseDriver.getDatabases();
              for (DatabaseDescriptor databaseDescriptor : databaseDescriptorList) {
                int id = databaseId++;
                DatabaseDescriptorHolder databaseDescriptorHolder =
                    new DatabaseDescriptorHolder(id, databaseDriver, databaseDescriptor);
                mDatabaseDescriptorHolderSparseArray.put(id, databaseDescriptorHolder);
                mDatabaseDescriptorHolderSet.add(databaseDescriptorHolder);
              }
            }
            FlipperArray result =
                ObjectMapper.databaseListToFlipperArray(mDatabaseDescriptorHolderSet);
            responder.success(result);
          }
        });
    connection.receive(
        GET_TABLE_DATA_COMMAND,
        new FlipperReceiver() {
          @Override
          public void onReceive(FlipperObject params, FlipperResponder responder) {
            GetTableDataRequest getTableDataRequest =
                ObjectMapper.flipperObjectToGetTableDataRequest(params);
            if (getTableDataRequest == null) {
              responder.error(
                  ObjectMapper.toErrorFlipperObject(
                      DatabasesErrorCodes.ERROR_INVALID_REQUEST,
                      DatabasesErrorCodes.ERROR_INVALID_REQUEST_MESSAGE));
            } else {
              DatabaseDescriptorHolder databaseDescriptorHolder =
                  mDatabaseDescriptorHolderSparseArray.get(getTableDataRequest.databaseId);
              if (databaseDescriptorHolder == null) {
                responder.error(
                    ObjectMapper.toErrorFlipperObject(
                        DatabasesErrorCodes.ERROR_DATABASE_INVALID,
                        DatabasesErrorCodes.ERROR_DATABASE_INVALID_MESSAGE));
              } else {
                try {
                  DatabaseGetTableDataResponse databaseGetTableDataResponse =
                      databaseDescriptorHolder.databaseDriver.getTableData(
                          databaseDescriptorHolder.databaseDescriptor,
                          getTableDataRequest.table,
                          getTableDataRequest.order,
                          getTableDataRequest.reverse,
                          getTableDataRequest.start,
                          getTableDataRequest.count);
                  responder.success(
                      ObjectMapper.databaseGetTableDataReponseToFlipperObject(
                          databaseGetTableDataResponse));
                } catch (Exception e) {
                  responder.error(
                      ObjectMapper.toErrorFlipperObject(
                          DatabasesErrorCodes.ERROR_SQL_EXECUTION_EXCEPTION, e.getMessage()));
                }
              }
            }
          }
        });
    connection.receive(
        GET_TABLE_STRUCTURE_COMMAND,
        new FlipperReceiver() {
          @Override
          public void onReceive(FlipperObject params, FlipperResponder responder) {
            GetTableStructureRequest getTableStructureRequest =
                ObjectMapper.flipperObjectToGetTableStructureRequest(params);
            if (getTableStructureRequest == null) {
              responder.error(
                  ObjectMapper.toErrorFlipperObject(
                      DatabasesErrorCodes.ERROR_INVALID_REQUEST,
                      DatabasesErrorCodes.ERROR_INVALID_REQUEST_MESSAGE));
            } else {
              DatabaseDescriptorHolder databaseDescriptorHolder =
                  mDatabaseDescriptorHolderSparseArray.get(getTableStructureRequest.databaseId);
              if (databaseDescriptorHolder == null) {
                responder.error(
                    ObjectMapper.toErrorFlipperObject(
                        DatabasesErrorCodes.ERROR_DATABASE_INVALID,
                        DatabasesErrorCodes.ERROR_DATABASE_INVALID_MESSAGE));
              } else {
                try {
                  DatabaseGetTableStructureResponse databaseGetTableStructureResponse =
                      databaseDescriptorHolder.databaseDriver.getTableStructure(
                          databaseDescriptorHolder.databaseDescriptor,
                          getTableStructureRequest.table);
                  responder.success(
                      ObjectMapper.databaseGetTableStructureResponseToFlipperObject(
                          databaseGetTableStructureResponse));
                } catch (Exception e) {
                  responder.error(
                      ObjectMapper.toErrorFlipperObject(
                          DatabasesErrorCodes.ERROR_SQL_EXECUTION_EXCEPTION, e.getMessage()));
                }
              }
            }
          }
        });
    connection.receive(
        GET_TABLE_INFO_COMMAND,
        new FlipperReceiver() {
          @Override
          public void onReceive(FlipperObject params, FlipperResponder responder) {
            GetTableInfoRequest getTableInfoRequest =
                ObjectMapper.flipperObjectToGetTableInfoRequest(params);
            if (getTableInfoRequest == null) {
              responder.error(
                  ObjectMapper.toErrorFlipperObject(
                      DatabasesErrorCodes.ERROR_INVALID_REQUEST,
                      DatabasesErrorCodes.ERROR_INVALID_REQUEST_MESSAGE));
            } else {
              DatabaseDescriptorHolder databaseDescriptorHolder =
                  mDatabaseDescriptorHolderSparseArray.get(getTableInfoRequest.databaseId);
              if (databaseDescriptorHolder == null) {
                responder.error(
                    ObjectMapper.toErrorFlipperObject(
                        DatabasesErrorCodes.ERROR_DATABASE_INVALID,
                        DatabasesErrorCodes.ERROR_DATABASE_INVALID_MESSAGE));
              } else {
                try {
                  DatabaseGetTableInfoResponse databaseGetTableInfoResponse =
                      databaseDescriptorHolder.databaseDriver.getTableInfo(
                          databaseDescriptorHolder.databaseDescriptor, getTableInfoRequest.table);
                  responder.success(
                      ObjectMapper.databaseGetTableInfoResponseToFlipperObject(
                          databaseGetTableInfoResponse));
                } catch (Exception e) {
                  responder.error(
                      ObjectMapper.toErrorFlipperObject(
                          DatabasesErrorCodes.ERROR_SQL_EXECUTION_EXCEPTION, e.getMessage()));
                }
              }
            }
          }
        });
    connection.receive(
        EXECUTE_COMMAND,
        new FlipperReceiver() {
          @Override
          public void onReceive(FlipperObject params, FlipperResponder responder) {
            ExecuteSqlRequest executeSqlRequest =
                ObjectMapper.flipperObjectToExecuteSqlRequest(params);
            if (executeSqlRequest == null) {
              responder.error(
                  ObjectMapper.toErrorFlipperObject(
                      DatabasesErrorCodes.ERROR_INVALID_REQUEST,
                      DatabasesErrorCodes.ERROR_INVALID_REQUEST_MESSAGE));
            } else {
              DatabaseDescriptorHolder databaseDescriptorHolder =
                  mDatabaseDescriptorHolderSparseArray.get(executeSqlRequest.databaseId);
              if (databaseDescriptorHolder == null) {
                responder.error(
                    ObjectMapper.toErrorFlipperObject(
                        DatabasesErrorCodes.ERROR_DATABASE_INVALID,
                        DatabasesErrorCodes.ERROR_DATABASE_INVALID_MESSAGE));
              } else {
                try {
                  DatabaseExecuteSqlResponse databaseExecuteSqlResponse =
                      databaseDescriptorHolder.databaseDriver.executeSQL(
                          databaseDescriptorHolder.databaseDescriptor, executeSqlRequest.value);
                  responder.success(
                      ObjectMapper.databaseExecuteSqlResponseToFlipperObject(
                          databaseExecuteSqlResponse));
                } catch (Exception e) {
                  responder.error(
                      ObjectMapper.toErrorFlipperObject(
                          DatabasesErrorCodes.ERROR_SQL_EXECUTION_EXCEPTION, e.getMessage()));
                }
              }
            }
          }
        });
  }