Content app with a String ItemId and single container

public class SimpleFlickrBrowserContentConnectorImpl implements SimpleFlickrBrowserContentConnector {
    private final FlickrService flickrService;
    private SimpleFlickrFlatContainer container;
    private SimpleFlickrItem defaultItem;

    @Inject
    public SimpleFlickrBrowserContentConnectorImpl(FlickrService flickrService) {
        this.flickrService = flickrService;
        container = new SimpleFlickrFlatContainer(flickrService);
    }

    public Container getContainer() {
        return container;
    }

    public String getItemUrlFragment(Object itemId) {
        return canHandleItem(itemId) ? (String) itemId : null;
    }

    public Object getItemIdByUrlFragment(String urlFragment) {
        return canHandleItem(urlFragment) ? urlFragment : null;
    }

    public Object getDefaultItemId() {
        if (defaultItem == null) {
            Photo photo = flickrService.getDefaultPhoto();
            if (photo != null) {
                defaultItem = new SimpleFlickrPropertysetItem(photo);
            }
        }
        return defaultItem;
    }

    public Item getItem(Object itemId) {
        return canHandleItem(itemId) ? container.getItem(itemId) : null;
    }

    public Object getItemId(Item item) {
        return item instanceof SimpleFlickrItem ? item.getItemProperty(SimpleFlickrItem.PROPERTY_PHOTOID) : null;
    }

    public boolean canHandleItem(Object itemId) {
        return itemId instanceof String && ((String) itemId).matches("^[0-9]");
    }
}

public class SimpleFlickrFlatContainer extends AbstractContainer implements Container, Container.Indexed, Refreshable {
    private static Logger log = LoggerFactory.getLogger(SimpleFlickrFlatContainer.class);
    private final FlickrService flickrService;
    private Map<Object, Class> properties = new HashMap<Object, Class>();
    private List<String> ids;
    private LinkedHashMap<String, SimpleFlickrItem> itemsMap = new LinkedHashMap<String, SimpleFlickrItem>();
    
	@Inject
    public SimpleFlickrFlatContainer(FlickrService flickrService) {
        this.flickrService = flickrService;
        configure();
    }

    public void refresh() {
        removeAllItems();
        loadAll();
    }

    private void loadAll() {
        ids = new ArrayList<String>();
        long start = System.currentTimeMillis();
        int sectionCounter = 0;
        log.info("Loading IDs in {}", this.getClass().getName());
        //
        Photosets albums = flickrService.getPhotosets();
        int albumCount = 0;
        if (albums != null &amp;&amp; albums.getTotal() > 0) {
            sectionCounter = 0;
            for (Photoset photoset : albums.getPhotosets()) {
                if (photoset != null &amp;&amp; photoset.getPhotoCount() > 0) {
                    String albumId = photoset.getId();
                    int photoCounter = 0;
                    PhotoList<Photo> photoList = flickrService.getPhotosFromAlbum(albumId);
                    for (Photo photo : photoList) {
                        String photoId = photo.getId();
                        if (!ids.contains(photoId)) {
                            ids.add(photoId);
                            SimpleFlickrItem item = new SimpleFlickrPropertysetItem(photo);
                            itemsMap.put(photoId, item);
                            sectionCounter++;
                            photoCounter++;
                        }
                    }
                }
            }
        }
    }

    public Item getItem(Object itemId) {
        return itemsMap.get(itemId);
    }

    public Collection<?> getItemIds() {
        if (ids == null) {
            loadAll();
        }
        return ids;
    }

    public Property getContainerProperty(Object itemId, Object propertyId) {
        SimpleFlickrItem item = (SimpleFlickrItem) getItem(itemId);
        if (item != null) {
            if (item != null) {
                Property property = item.getItemProperty(propertyId);
                if (property != null) {
                    return property;
                }
            }
        }
        return null;
    }

    public Class<?> getType(Object propertyId) {
        return SimpleFlickrItem.IDs.getIDs().get(propertyId);
    }

    public int size() {
        return ids.size();
    }

    public boolean containsId(Object itemId) {
        return ids.contains(itemId);
    }

    public Item addItem(Object itemId) throws UnsupportedOperationException {
        throw new UnsupportedOperationException("Class does NOT SUPPORT this method.");
    }

    public boolean addContainerProperty(Object propertyId, Class<?> type, Object defaultValue) throws UnsupportedOperationException {
        properties.put(propertyId, type);
        return properties.containsKey(propertyId);
    }

    public boolean removeContainerProperty(Object propertyId) throws UnsupportedOperationException {
        properties.remove(propertyId);
        return !properties.containsKey(propertyId);
    }

    public boolean removeAllItems() throws UnsupportedOperationException {
        ids = null;
        itemsMap.clear();
        return ids == null &amp;&amp; itemsMap.size() == 0;
    }

    public Collection<?> getContainerPropertyIds() {
        return SimpleFlickrItem.IDs.getIDs().keySet();
    }

    private void configure() {
        Map<String, Class> props = SimpleFlickrItem.IDs.getIDs();
        for (String id : props.keySet()) {
            addContainerProperty(id, props.get(id), null);
        }
    }

    public int indexOfId(Object itemId) {
        List<String> keys = new ArrayList<String>(itemsMap.keySet());
        return keys.indexOf(itemId);
    }

    public Object getIdByIndex(int index) {
        List<String> keys = new ArrayList<String>(itemsMap.keySet());
        return keys.get(index);
    }

    public List<?> getItemIds(int startIndex, int numberOfItems) {
        if (itemsMap == null) {
            loadAll();
        }
        return new ArrayList<String>(itemsMap.keySet());
    }

    public Object nextItemId(Object itemId) {
        List<String> keys = new ArrayList<String>(itemsMap.keySet());
        int index = keys.indexOf(itemId);
        if (index < keys.size() - 1) {
            return keys.get(index + 1);
        }
        return null;
    }

    public Object prevItemId(Object itemId) {
        List<String> keys = new ArrayList<String>(itemsMap.keySet());
        int index = keys.indexOf(itemId);
        if (index > 0) {
            return keys.get(index - 1);
        }
        return null;
    }

    public Object firstItemId() {
        List<String> keys = new ArrayList<String>(itemsMap.keySet());
        return keys.get(0);
    }

    public Object lastItemId() {
        List<String> keys = new ArrayList<String>(itemsMap.keySet());
        return keys.get(keys.size() - 1);
    }

    public boolean isFirstId(Object itemId) {
        List<String> keys = new ArrayList<String>(itemsMap.keySet());
        return keys.get(0).equals(itemId);
    }

    public boolean isLastId(Object itemId) {
        List<String> keys = new ArrayList<String>(itemsMap.keySet());
        return keys.get(keys.size() - 1).equals(itemId);
    }
}

public class SimpleFlickrThumbnailPresenter extends ThumbnailPresenter {
    private final SimpleFlickrBrowserContentConnector contentConnector;
    private static int thumbnailSize = 150;

    @Inject
    public SimpleFlickrThumbnailPresenter(ThumbnailView view, ImageProvider imageProvider, ComponentProvider componentProvider, ContentConnector contentConnector) {
        super(view, imageProvider, componentProvider);
        this.contentConnector = (SimpleFlickrBrowserContentConnector) contentConnector;
    }


    protected Container initializeContainer() {
        ThumbnailContainer container = new ThumbnailContainer(getImageProvider(), new ThumbnailContainer.IdProvider() {
            @Override
            public List<Object> getItemIds() {
                return new ArrayList<Object>(contentConnector.getContainer().getItemIds());
            }
        });
        container.setThumbnailHeight(thumbnailSize);
        container.setThumbnailWidth(thumbnailSize);
        return container;
    }


    public ThumbnailView start(WorkbenchDefinition workbench, EventBus eventBus, String viewTypeName, ContentConnector contentConnector) {
        ThumbnailView view = (ThumbnailView) super.start(workbench, eventBus, viewTypeName, contentConnector);
        view.setThumbnailSize(thumbnailSize, thumbnailSize);
        return view;
    }
}

public class SimpleFlickrThumbnailPresenterDefinition extends ThumbnailPresenterDefinition {
    public SimpleFlickrThumbnailPresenterDefinition() {
        setImplementationClass(SimpleFlickrThumbnailPresenter.class);
    }
}

public class SimpleFlickrBrowserPreviewImageProvider implements ImageProvider {


    private final FlickrService flickrService;

    @Inject
    public SimpleFlickrBrowserPreviewImageProvider(FlickrService flickrService) {
        this.flickrService = flickrService;
    }

    @Override
    public String getPortraitPath(Object itemId) {
        return null;
    }

    @Override
    public String getThumbnailPath(Object itemId) {
        return null;
    }

    @Override
    public String resolveIconClassName(String mimeType) {
        return null;
    }

    @Override
    public Object getThumbnailResource(Object itemId, String generator) {
        Resource resource = null;

        if (itemId instanceof String) {
            String photoId = (String) itemId;
            if (StringUtils.isNotBlank(photoId)) {
                /**
                 * To grep data from flickr API here is very costly - since a thumbnail container could call this method here many 100 times.
                 * Here it would make sense to add the smallUrl as a property of a more sophisticated ItemId
                 */
                Photo photo = flickrService.getPhoto(photoId);
                if (photo != null) {
                    String smallPicUrl = photo.getSmallUrl();
                    if (StringUtils.isNotBlank(smallPicUrl)) {
                        resource = new ExternalResource(smallPicUrl);
                    }
                }
            }
        }
        return resource;
    }
}

public class SimpleFlickrListPresenterDefinition extends ListPresenterDefinition {
    public SimpleFlickrListPresenterDefinition() {
        setImplementationClass(SimpleFlickrListPresenter.class);
    }
}

public class SimpleFlickrListPresenter extends ListPresenter {
    private final SimpleFlickrBrowserContentConnector contentConnector;

    @Inject
    public SimpleFlickrListPresenter(ListView view, ComponentProvider componentProvider, ContentConnector contentConnector) {
        super(view, componentProvider);
        this.contentConnector = (SimpleFlickrBrowserContentConnector) contentConnector;
    }
    @Override
    protected Container initializeContainer() {
        return contentConnector.getContainer();
    }
}