Close Menu

sgimagecache

Welcome to the documentation for SGImageCache! SGImageCache is a versatile and high-performance library for iOS that brings advanced image caching and loading capabilities to your app. With SGImageCache, you can enhance your app’s smoothness and responsiveness by efficiently managing image downloads and caching.

Installation

To get started with SGImageCache, follow these steps:

  1. Ensure that you have the latest version of Xcode installed on your development machine.
  2. Open your Xcode project where you want to integrate SGImageCache.
  3. Add SGImageCache as a dependency using one of the following methods:
    • Swift Package Manager: In Xcode, go to File → Add Packages…, and enter the repository URL: https://github.com/sgundavarapu/SGImageCache.git
    • CocoaPods: Add the following line to your Podfile:
    pod 'SGImageCache'
  4. Import the SGImageCache framework in your Swift file:
    5. import SGImageCache

Usage

Now that you have SGImageCache integrated into your project, let’s explore some key concepts and examples to help you make the most out of this powerful library.

Initializing the Image Cache

Prior to loading and caching images, you need to initialize the image cache. The best place to do this is in the application(_:didFinishLaunchingWithOptions:) method of your app delegate.

func application(_ application: UIApplication, didFinishLaunchingWithOptions launchOptions: [UIApplication.LaunchOptionsKey: Any]?) -> Bool {
    // Initialize the SGImageCache
    SGImageCache.shared.initializeCache()
    return true
}

Loading Images

SGImageCache provides a convenient way to load images asynchronously. You can use the provided loadImage(fromURL:completion:) method to load and display an image in an UIImageView.

let imageView = UIImageView()
let imageURL = URL(string: "https://example.com/image.jpg")!

SGImageCache.shared.loadImage(fromURL: imageURL) { image in
    imageView.image = image
}

Caching Images

One of the primary benefits of SGImageCache is its efficient image caching mechanism. Use the cacheImage(_:forURL:) method to cache an image for a given URL.

let image = UIImage(named: "example")
let imageURL = URL(string: "https://example.com/image.jpg")!

SGImageCache.shared.cacheImage(image, forURL: imageURL)

Advanced Topics

Custom Caching Configuration

SGImageCache allows you to customize various caching parameters to suit your app’s specific requirements. These parameters include cache size, expiration policy, and memory limit. To customize the caching configuration, use the SGImageCacheConfig class.

// Create configuration
let config = SGImageCacheConfig()
config.cacheMaxSize = 100 * 1024 * 1024 // Set max cache size to 100MB
config.memoryLimitPercentage = 0.5 // Set memory limit to 50%
config.expirationPolicy = .never // Set image expiration policy

// Assign configuration to SGImageCache
SGImageCache.shared.config = config

Memory Warning Handling

SGImageCache includes built-in memory warning handling to clear the memory cache automatically when a memory warning is received. However, you can also manually invoke the clearMemoryCache() method to clear the memory cache at any time.

// Automatically handled when a memory warning is received
SGImageCache.shared.clearMemoryCache()

Preload Images

In some scenarios, you may want to preload images in advance to minimize latency when displaying them later. Use the preloadImages(forURLs:) method to efficiently preload a batch of images.

let imageURLs = [URL(string: "https://example.com/image1.jpg")!, URL(string: "https://example.com/image2.jpg")!]

SGImageCache.shared.preloadImages(forURLs: imageURLs)

Examples

Here are a few additional examples to provide you with a clearer understanding of how to leverage SGImageCache in practice.

Example 1 – Lazy Load

Lazy loading is a common technique used to defer the loading of images until they are actually needed. Here’s an example of lazy loading using SGImageCache:

let imageView = UIImageView()
let imageURL = URL(string: "https://example.com/image.jpg")!

// Set a placeholder image while the actual image loads
imageView.image = UIImage(named: "placeholder")

// Load the image using SGImageCache
SGImageCache.shared.loadImage(fromURL: imageURL) { image in
    imageView.image = image
}

Example 2 – Preload On Scroll

Preloading images while scrolling is a powerful way to ensure smooth and seamless user experience. Here’s an example of preloading images in a table view using SGImageCache:

func tableView(_ tableView: UITableView, cellForRowAt indexPath: IndexPath) -> UITableViewCell {
    let cell = tableView.dequeueReusableCell(withIdentifier: "ImageCell", for: indexPath) as! ImageCell
    let imageURL = imageUrls[indexPath.row]
    
    // Set a placeholder image while the actual image loads
    cell.imageView?.image = UIImage(named: "placeholder")
    
    // Load the image using SGImageCache
    SGImageCache.shared.loadImage(fromURL: imageURL) { image in
        DispatchQueue.main.async {
            cell.imageView?.image = image
        }
    }
    
    return cell
}

Conclusion

Congratulations! You have successfully integrated SGImageCache into your iOS project. You now have the power to optimize image loading and caching, improving your app’s performance and user experience. Feel free to explore the documentation further and experiment with the library’s various features and customization options.