Working with Albums

The Cloudike Photos SDK allows you to create and edit albums, as well as get a list of albums and their content.

Get List of Albums

CloudikePhotosKit provides an album information for the client application through the special AlbumsAdapter object, which is based on NSFetchedResultsController.

To initialize AlbumsAdapter, you need to call the following methods:

let adapter = photosManager.albumsService.albumsAdapter(collectionView)

• collectionView: UICollectionView - instance of the UICollectionView object used to display albums.

iOS13 or Higher Support

In iOS13 or later, you should implement closures to initialize objects to display section headers and cells.

Cell

var cell: ((UICollectionView, IndexPath)->UICollectionViewCell)?

Example closure for UICollectionViewCell:

adapter.cell = { collectionView, indexPath in
    collectionView.dequeueReusableCell(withReuseIdentifier: <CellReuseIdentifier>, for: indexPath)
}

Adapter Preparings

This method should be called after setting up the closures.

adapter.configure()

iOS12 or Lower Support

To display a header and a cell on devices with iOS12 or lower, you should implement the following delegate methods:

func collectionView(_ collectionView: UICollectionView, cellForItemAt indexPath: IndexPath) -> UICollectionViewCell

func collectionView(_ collectionView: UICollectionView, viewForSupplementaryElementOfKind kind: String, at indexPath: IndexPath) -> UICollectionReusableView

UICollectionViewDataSource

You need to implement the UICollectionViewDataSource methods for your UICollectionView

// MARK: - UICollectionViewDataSource
func collectionView(_ collectionView: UICollectionView, numberOfItemsInSection section: Int) -> Int {
    return adapter.itemsCount(section)
}

Get all Albums

Get an array which contains all albums items.

func getAlbums() -> [CloudikeAlbumItem]

Get Album

Get an album by backend identifier:

func getAlbum(_ albumId: String) -> CloudikeAlbumItem?

The parameters:

• albumId: String - album identifier.

Update Albums

To start reading the albums from the backend, you need to call the following methods:

photosManager.albumsService.update(fullRefresh: fullRefresh, completion: { [weak self] (result) in
    switch result {
    case .success(_):
        NSLog("Albums> update> success")
    case let .failure(error):
        NSLog("Albums> update> error: \(error)")
    }
})

The parameters:

• fullRefresh: Bool - If true, then the list of albums is fully read from the backend. The refresh procedure may take a long time. If false, then the reading is incremental, only the latest changes are read.
• completion: (Swift.Result<Void, CloudikePhotosError>) -> () - The completion handler to receive the result and the error objects.

Create Album

To create an album, you need to call the following methods:

photosManager.albumsService.createAlbum(description: name, type: .simple, isShareForEdit: false, sharedExpiration: nil, completion: { (result) in
    switch result {
    case let .success(album):
        NSLog("Albums> create> success: \(album)")
    case let .failure(error):
        NSLog("Albums> create> error: \(error)")
    }
})

In this example, a simple album is created. The parameters of the createAlbum function are as follows:

• description: String - The name of the album.
• type: NewAlbumType - The type of the album (see below).
• isShareForEdit: Bool - If true, then the album can be edited by accessing the album link.
• sharedExpiration: Int64? - Expiration of shared link (optional).
• completion: (Swift.Result<CloudikeAlbumItem, CloudikePhotosError>) -> () - The completion handler to receive the CloudikeAlbumItem and the error objects.

An album can be one of the following types:

• NewAlbumType.simple - The type of a simple album.
• NewAlbumType.shared - The type of a shared album. An album that has a link for viewing and/or editing (depending on the isSharedForEdit parameter).
• NewAlbumType.hiddenShared - The type of a hidden shared album.

Delete Album

To delete an album, you need to call the following methods:

photosManager.albumsService.deleteAlbum(id: albumId, completion: { [weak self] (result) in
    switch result {
    case .success(_):
        NSLog("Album> delete> success")
    case let .failure(error):
        NSLog("Album> delete> error: \(error)")
    }
})

The parameters of the deleteAlbum function are as follows:

• id: String - The identifier of the album.
• completion: (Swift.Result<Void, CloudikePhotosError>) -> () - The completion handler to receive the result and the error objects.

Update Album items

To update albums photos/videos from the backend, you need to call the following methods:

photosManager.albumsService.updateItems(id: String, fullRefresh: fullRefresh, completion: { [weak self] (result) in
    switch result {
    case .success(_):
        NSLog("Albums> update> success")
    case let .failure(error):
        NSLog("Albums> update> error: \(error)")
    }
})

The parameters of the updateItems function are as follows:

• id: String - The identifier of the album.
• fullRefresh: Bool - If true, then the list of albums is fully read from the backend. The refresh procedure may take a long time. If false, then the reading is incremental, only the latest changes are read.
• completion: (Swift.Result<Void, CloudikePhotosError>) -> () - The completion handler to receive the result and the error objects.

Update Album Properties

To update the album properties, you need to call the following methods:

photosManager.albumsService.updateAlbum(id: albumId, completion: { [weak self] (result) in
    switch result {
    case let .success(album):
        NSLog("Album> updateProperties> success: \(album)")
    case let .failure(error):
        NSLog("Album> updateProperties> error: \(error)")
    }
})

The parameters of the updateAlbum function are as follows:

• id: String - The identifier of the album.
• completion: (Swift.Result<CloudikeAlbumItem, CloudikePhotosError>) -> () - The completion handler to receive CloudikeAlbumItem and the error objects.

Edit Album Properties

To edit the album properties, you need to call the following methods:

photosManager.albumsService.editAlbum(id: albumId, description: name, type: type, isShareForEdit: isShareForEdit, sharedExpiration: expirationTime, completion: { [weak self] (result) in
    switch result {
    case let .success(album):
        NSLog("Album> editProperties> success: \(album)")
    case let .failure(error):
        NSLog("Album> editProperties> error: \(error)")
    }
})

The parameters of the editAlbum function are as follows:

• id: String - The identifier of the album.
• description: String - The name of the album.
• type: NewAlbumType - The type of the album (see below).
• isShareForEdit: Bool - If true, then the album can be edited by accessing the album link.
• sharedExpiration: Int64? - Expiration of a shared link (optional).
• completion: (Swift.Result<CloudikeAlbumItem, CloudikePhotosError>) -> () - The completion handler to receive the CloudikeAlbumItem and the error objects.

Create Public Links

To create a public link to an album, you can use the shareAlbum function.

photosManager.albumsService.shareAlbum(id: albumId, completion: { result in
    switch result {
    case .success(let albumItem):
        print("Album shared link> \(albumItem.sharedLink)")
    case let .failure(error):
        print("Album sharing error: \(error)")
    }
})

The parameters of the shareAlbum function are as follows:

• id: String - The identifier of the album.
• completion: (Swift.Result<CloudikeAlbumItem, CloudikePhotosError>) -> () - The completion handler to receive the result and the error objects. CloudikeAlbumItem contains result link as a sharedLink property

Delete Public Links

To delete a public link from album, you can use the shareAlbum function.

photosManager.albumsService.unshareAlbum(id: albumId, completion: { result in
    switch result {
    case .success(let albumItem):
        NSLog("Album sharing success \(albumItem)")
    case let .failure(error):
        NSLog("Album sharing error: \(error)")
    }
})

The parameters of the unshareAlbum function are as follows:

• id: String - The identifier of the album.
• completion: (Swift.Result<CloudikeAlbumItem, CloudikePhotosError>) -> () - The completion handler to receive the result and the error objects.

Working with Album Content

Get Album Content

CloudikePhotosKit provides photo information in the album for the client application through the special AlbumItemsAdapter object, which is based on NSFetchedResultsController.

To initialize AlbumItemsAdapter, you need to call the following methods:

let adapter = photosManager.albumsService.albumItemsAdapter(albumId: id, collectionView: collectionView)

The parameters of the albumItemsAdapter function are as follows:

• albumId: String - The identifier of the album.
• collectionView: UICollectionView - instance of the UICollectionView object used to display photos.

Update Album Content

To start reading the album content (list of album photos) from the backend, you need to call the following methods:

photosManager.albumsService.updateItems(id: albumId, fullRefresh: fullRefresh, completion: { [weak self] (result) in
    switch result {
    case .success(_):
        NSLog("Album> updateItems> success")
    case let .failure(error):
        NSLog("Album> updateItems> error: \(error)")
    }
})

The parameters of the updateItems function are as follows:

• id: String - The identifier of the album.
• fullRefresh: Bool - If true, then the list of photos is fully read from the backend. The refresh procedure may take a long time. If false, then the reading is incremental, only the latest changes are read.
• completion: (Swift.Result<Void, CloudikePhotosError>) -> () - The completion handler to receive the result and the error objects.

Add/delete Photos to/from Album

To add photos to the existing album, you need to call the following methods:

photosManager.albumsService.editAlbumItems(id: albumId, itemsForAdd: items, itemsForDelete: [], completion: { [weak self] (result) in
    switch result {
    case let .success(album):
        NSLog("Album> editItems> success: \(album)")
    case let .failure(error):
        NSLog("Album> editItems> error: \(error)")
    }
})

The parameters:

The parameters of the editAlbumItems function are as follows:

• id: String - The identifier of the album.
• itemsForAdd: Array<CloudikeMediaItem> - items to be added.
• itemsForDelete: Array<CloudikeMediaItem> - items to be deleted.
• completion: (Swift.Result<CloudikeAlbumItem, CloudikePhotosError>) -> () - The completion handler to receive the CloudikeAlbumItem and the error objects.

The function editAlbumItems returns the Cancellable object. If you need to cancel editing call, use the following operation:

cancellable.cancel()

Remove Photos from Album

To remove photos from an album, you need to call the following methods:

photosManager.albumsService.editAlbumItems(id: albumId, itemsForAdd: [], itemsForDelete: items, completion: { [weak self] (result) in
    switch result {
    case let .success(album):
        NSLog("Album> editItems> success: \(album)")
    case let .failure(error):
        NSLog("Album> editItems> error: \(error)")
    }
})

The parameters:

• id: String - The identifier of the album.
• itemsForAdd: [CloudikeMediaItem] - The list of photos to be added to the album.
• itemsForDelete: [CloudikeMediaItem] - The list of photos to be removed from the album.
• completion: (Swift.Result<CloudikeAlbumItem, CloudikePhotosError>) -> () - The completion handler to receive the CloudikeAlbumItem and the error objects.