Creating POC using LCP Framework

[Vijay-Waghmare]

Hello there,
I'm trying to create one POC using the LCP server. I have integrated your private R2LCPClient framework into my demo project, but the problem is that you were provided with this code: "https://github.com/readium/r2-lcp-swift," which is not clear on how I can connect it to the LCP server and get the data. How can I use it in my real app project? I went through your documentation, which is not clear to me on how I can do this.
The flow for the demo app is also not clear for LCP server integration.
Do you have any demo projects for which you did LCP server integration?

[mickael-menu]

Before I answer, could you give me some additional info?

• Are you using the Readium Swift toolkit to render the books in your iOS application? (using the EPUB navigator for example)
• If not, what do you need exactly?
• Do you have access to the private LCP library provided by EDRLab?

By the way the r2-lcp-swift repo is deprecated, everything is in swift-toolkit now. There is a ReadiumLCP module that replaces the old r2-lcp-swift.

[Vijay-Waghmare]

Thanks for response,

• Yes, I'm using Swift toolkit codebase.

• I need to now the below code is provided for LCP server, But how I can use it and make CLP server call?
  How I can make connection to LCP Server and get the data?
  ```
  import R2LCPClient
  import ReadiumLCP

      let lcpService = LCPService(client: LCPClient())
  
      /// Facade to the private R2LCPClient.framework.
      class LCPClient: ReadiumLCP.LCPClient {
  
               func createContext(jsonLicense: String, hashedPassphrase: String, pemCrl: String) throws -> LCPClientContext {
                   return try R2LCPClient.createContext(jsonLicense: jsonLicense, hashedPassphrase: hashedPassphrase, pemCrl: pemCrl)
               }
               func decrypt(data: Data, using context: LCPClientContext) -> Data? {
                   return R2LCPClient.decrypt(data: data, using: context as! DRMContext)
               }
  
               func findOneValidPassphrase(jsonLicense: String, hashedPassphrases: [String]) -> String? {
                    return R2LCPClient.findOneValidPassphrase(jsonLicense: jsonLicense, hashedPassphrases: hashedPassphrases)
               }
  
      }
      ```
  

• Yes, I have access to private LCP library provided by EDRLab

My main concern is I'm not able to see LCP server related code in Swift toolkit framework.

[mickael-menu]

What do you need to do exactly? As integrator you don't make an explicit connection to the LCP server. What you can do with the Readium toolkit is:

• Acquire a full protected publication file from a license document (.lcpl file).
• Decrypt the resources of a protected publication inside the navigator.
• Renew a loan or return a publication.

[Vijay-Waghmare]

Hi Mickaël Menu,
Now I have encrypted book data url which is provided by backed team,

• Can you please guide me how I can use it and where Or you can provide me some code here to decrypt it?
• What is this CLP check and how it works?
  #if LCP drmLibraryServices.append(LCPLibraryService()) #endif

[mickael-menu]

I'll try to find some time to draft a proper user guide after the holidays. But in the meantime I can give you a quick overview.

The #if LCP checks are there to allow the test app code to run even if you don't have the private lcplib project which is required to run the LCP code. You don't need these in your application, if you always support LCP.

Setup

1. Embed and import the private R2LCPClient framework provided by EDRLab in your application. They provided instructions on how to do that.
2. Embed and import the public ReadiumLCP framework part of the Readium Swift toolkit (this project).
3. Create a facade for the private R2LCPClient. This acts as the glue between the two frameworks, as they don't know about each other. You can copy this one:

   /// Facade to the private R2LCPClient.framework.
   class LCPClient: ReadiumLCP.LCPClient {
       func createContext(jsonLicense: String, hashedPassphrase: String, pemCrl: String) throws -> LCPClientContext {
           try R2LCPClient.createContext(jsonLicense: jsonLicense, hashedPassphrase: hashedPassphrase, pemCrl: pemCrl)
       }
   
       func decrypt(data: Data, using context: LCPClientContext) -> Data? {
           R2LCPClient.decrypt(data: data, using: context as! DRMContext)
       }
   
       func findOneValidPassphrase(jsonLicense: String, hashedPassphrases: [String]) -> String? {
           R2LCPClient.findOneValidPassphrase(jsonLicense: jsonLicense, hashedPassphrases: hashedPassphrases)
       }
   }

4. Create an instance of ReadiumLCP.LCPService. This provides LCP APIs to your app.

   let lcpService = LCPService(client: LCPClient())

Retrieving an LCP protected publication

An LCP server grants access to an LCP protected publication through a Licence document (.lcpl file). The LCPService can be used to retrieve the actual publication file (.epub) protected with LCP using:

lcpService.acquirePublication(from: lcplFile) { result in
    switch result {
    case let .success(pub):
        print("The protected EPUB file is located at \(pub.localURL)")
    case let .failure(error):
        print("error: \(error)")
    case .cancelled:
        print("download cancelled")
    }
}

Once you have the protected file, you can import it in your bookshelf as with any other book.

Decrypting and rendering the LCP protected publication

This section assumes that you are already familiar with opening an EPUB publication and rendering it with the EPUB navigator.

To be able to open and render the LCP protected publication in a navigator, you need to create the Streamer object using the LCP content protection provided by the LCPService.

let streamer = Streamer(
    contentProtections: [lcpService.contentProtection()]
)

Then, open the publication with the Streamer. If you set allowUserInteraction: true and provide a host UIViewController for sender, the toolkit will show a dialog to ask for the user passphrase if it is not already saved. Alternatively, you can provide the passphrase as the credentials parameter of Streamer.open().

streamer.open(
    asset: FileAsset(url: epubFileURL),
    allowUserInteraction: true,
    sender: hostViewController
) { result in
    switch result {
    case let .success(publication):
        // Publication is successfully opened, but it might not be unlocked, for example if we couldn't
        // ask the user for their passphrase. We can check the `publication.protectionError` and
        //`publication.isRestricted` for that.
        if publication.isRestricted {
            if let error = publication.protectionError {
                // There's a problem with the LCP licence, for example because it expired. We need to show
                // the error to the user.
            } else {
                // We don't have the passphrase for this licence, we can consider that the opening is cancelled.
            }
        } else {
            // Publication successfully opened and unlocked. We can render it with the `EPUBNavigatorViewController`.
       }
    case let .failure(error):
        // The publication couldn't be opened at all. 
    case .cancelled:
        // The user might have cancelled the passphrase dialog.
       break
    }
}

Hopefully that will get you started.

[Vijay-Waghmare]

Hi Mickaël Menu,
Thanks for this information. It's super helpful. It saves my days.

I have some questions:

1. This model 'R2Client framework looks different than the Swift Toolkit demo app', so do I need to create a locale database from my side to store these books? and read it, I am not able to see database integration in this private repo.
2. Same also, so I need to handle the top tool bar from my side, which contains settings, bookmarks, value buttons, etc. Or am I missing something?
3. Or is there any way I can use the existing locale DB and flow as they are?

By the way, thank you so much for this code!

[mickael-menu]

I'm not sure I understand your questions.

Anything related to persistence storage (database) is part of the app, and not the responsibility of the Readium toolkit. Similarly, Readium doesn't provide any UI (top tool bar, buttons, bookmark panels, etc.). The Navigator only shows the content of the book, and you need to build your UI around it.

The Test App is a sample app showing how to use the Readium toolkit. It has an example database and basic UI built on top of Readium.

[Vijay-Waghmare]

Thanks a lot Mickaël.

[Vijay-Waghmare]

Mickaël,

The above code works fine for the POC for now, but I'm soon going to start building a new project using the LCP server and DRM services.
But the code that you provided is deprecated. Am I missing something?

As you said all the code moved to Swift toolkit, So how I can open .lcpl file using Swift toolkit framework?