How to use com.atlassian.streams.spi

@Override
public StreamsActivityProvider getModule()
{
  initModules();  // we need to call this here in case enabled() wasn't called, as is in the case in Bamboo 2.7
  return provider;
}

/**
 * If true, the values of this filter option should be shown as separate pseudo-providers
 * in the filter UI.
 * 
 * @return True if the values of the filter option should be shown as provider aliases
 */
public boolean isProviderAlias()
{
  return streamsFilterOption.isProviderAlias();
}

/**
 * The filter option i18n key
 *
 * @return The filter option i18n key
 */
public String getI18nKey()
{
  return streamsFilterOption.getI18nKey();
}

StreamsFilterOptionImpl(StreamsFilterOption.Builder builder)
{
  this.key = builder.getKey();
  this.displayName = builder.getDisplayName();
  this.helpTextI18nKey = builder.getHelpTextI18nKey();
  this.i18nKey = builder.getI18nKey();
  this.type = builder.getType();
  this.unique = builder.isUnique();
  this.providerAlias = builder.isProviderAlias();
  this.values = builder.getValues();
}

public boolean remove(ActivityItem activityItem)
{
  evictor.apply(activityItem.getEntity());
  return super.remove(activityItem);
}

/**
 * Creates a {@code Predicate} from the {@link CONTAINS} and {@link DOES_NOT_CONTAIN} operators in the list of filters.  The returned
 * {@code Predicate} uses the {@link Function}s returned by {@link isContaining} and {@link isNotContaining} to construct the sub
 * {@code Predicate}s for each {@code Operator}, and then {@link and}s them all together.
 *
 * @param filters filters to create a predicate for
 * @return {@code Predicate} from the {@code CONTAINS} and {@code DOES_NOT_CONTAIN} filters
 */
public static Predicate<String> containsAndDoesNotContain(Iterable<Pair<Operator, Iterable<String>>> filters)
{
  return containsAndDoesNotContain(filters, isContaining(), isNotContaining());
}

  public Void apply(T instance)
  {
    evictor.apply(instance);
    return null;
  }
});

  public Predicate<String> apply(final Iterable<String> xs)
  {
    return new CaseInsensitive(xs);
  }
}

/**
 * {@code Predicate} for removing any {@code StreamsEntry}s that match notted "filterUser" filters.
 *
 * @param request the {@code ActivityRequest} containing the filters
 * @return the {@code Predicate}
 */
public static Predicate<Iterable<String>> notInUsers(ActivityRequest request)
{
  return new NotInUsers(request);
}

/**
 * {@code Predicate} for filtering involving a {@code StreamEntry}'s authors.
 *
 * @param authorPredicate the author predicate to filter on
 * @return the {@code Predicate}
 */
public static Predicate<StreamsEntry> entryAuthors(Predicate<Iterable<String>> authorPredicate)
{
  return new EntryAuthors(authorPredicate);
}

/**
 * The filter option key
 *
 * @return The filter option key
 */
public String getKey()
{
  return streamsFilterOption.getKey();
}

/**
 * The filter option display name
 *
 * @return The filter option display name
 */
public String getDisplayName()
{
  return streamsFilterOption.getDisplayName();
}

/**
 * Whether the filter option accepts multiple values or not
 *
 * @return Whether the filter option accepts multiple values or not
 */
public boolean isUnique()
{
  return streamsFilterOption.isUnique();
}

/**
 * @return a {@code Function} which takes a list of {@code String}s and returns a {@code Predicate} which determines
 * if a {@code String} matches the {@code Predicate} created from {@code f} in a case insensitive way.  An example
 * of this is in practice is allowing a case insensitive check if a {@code String} is in a list {@code String}s,
 * {@code caseInsensitive(isIn())}.
 */
public static Function<Iterable<String>, Predicate<String>> caseInsensitive(final Function<Iterable<String>, Predicate<String>> f)
{
  return new AsCaseInsensitive(f);
}

/**
 * The filter option type
 *
 * @return The filter option type
 */
public StreamsFilterType getFilterType()
{
  return streamsFilterOption.getFilterType();
}

  public Boolean apply(T t, Boolean allSuccess)
  {
    return add(t) && allSuccess;
  }
});

public StreamsCommentHandler getCommentHandler()
{
  initModules();
  return commentHandler;
}

public StreamsFilterOptionProvider getFilterOptionProvider()
{
  initModules();
  return filterOptionProvider;
}

public StreamsKeyProvider getKeyProvider()
{
  initModules();
  return keyProvider;
}

public StreamsValidator getValidator()
{
  initModules();
  return validator;
}