android/libwvdrmengine/cdm/core/include/cdm_session.h

// Copyright 2012 Google Inc. All Rights Reserved.

#ifndef CDM_BASE_CDM_SESSION_H_
#define CDM_BASE_CDM_SESSION_H_

#include <set>

#include "crypto_session.h"
#include "license.h"
#include "policy_engine.h"
#include "wv_cdm_event_listener.h"
#include "wv_cdm_types.h"

namespace wvcdm {

// TODO(kqyang): Do we need it? CdmKey not defined yet
// typedef std::map<KeyId, CdmKey*> CdmSessionKeys;

class CdmSession {
 public:
  CdmSession() : session_id_(GenerateSessionId()), license_received_(false),
      reinitialize_session_(false), license_type_(kLicenseTypeStreaming) {}
  ~CdmSession() {}

  CdmResponseType Init();
  CdmResponseType ReInit();
  bool DestroySession();

  CdmResponseType RestoreOfflineSession(const CdmKeySetId& key_set_id,
                                        const CdmLicenseType license_type);

  void set_key_system(const CdmKeySystem& ksystem) { key_system_ = ksystem; }
  const CdmKeySystem& key_system() { return key_system_; }

  const CdmSessionId& session_id() { return session_id_; }

  bool VerifySession(const CdmKeySystem& key_system,
                     const CdmInitData& init_data);

  CdmResponseType GenerateKeyRequest(const CdmInitData& init_data,
                                     const CdmLicenseType license_type,
                                     const CdmAppParameterMap& app_parameters,
                                     CdmKeyMessage* key_request,
                                     std::string* server_url);

  // AddKey() - Accept license response and extract key info.
  CdmResponseType AddKey(const CdmKeyResponse& key_response,
                         CdmKeySetId* key_set_id);

  // CancelKeyRequest() - Cancel session.
  CdmResponseType CancelKeyRequest();

  // Query license information
  CdmResponseType QueryKeyStatus(CdmQueryMap* key_info);

  // Query session control info
  CdmResponseType QueryKeyControlInfo(CdmQueryMap* key_info);

  // Decrypt() - Accept encrypted buffer and return decrypted data.
  CdmResponseType Decrypt(bool is_encrypted,
                          bool is_secure,
                          const KeyId& key_id,
                          const uint8_t* encrypt_buffer,
                          size_t encrypt_length,
                          const std::vector<uint8_t>& iv,
                          size_t block_offset,
                          void* decrypt_buffer,
                          size_t decrypt_buffer_offset,
                          bool is_video);

  // License renewal
  // GenerateRenewalRequest() - Construct valid renewal request for the current
  // session keys.
  CdmResponseType GenerateRenewalRequest(CdmKeyMessage* key_request,
                                         std::string* server_url);

  // RenewKey() - Accept renewal response and update key info.
  CdmResponseType RenewKey(const CdmKeyResponse& key_response);

  // License release
  // GenerateReleaseRequest() - Construct valid release request for the current
  // session keys.
  CdmResponseType GenerateReleaseRequest(CdmKeyMessage* key_request,
                                         std::string* server_url);

  // RenewKey() - Accept renewal response and update key info.
  CdmResponseType ReleaseKey(const CdmKeyResponse& key_response);

  bool IsKeyValid(const KeyId& key_id);

  bool AttachEventListener(WvCdmEventListener* listener);
  bool DetachEventListener(WvCdmEventListener* listener);

  void OnTimerEvent();
  void OnKeyReleaseEvent(CdmKeySetId key_set_id);

 private:

  // Generate unique ID for each new session.
  CdmSessionId GenerateSessionId();
  CdmKeySetId GenerateKeySetId(CdmInitData& pssh_data);

  bool LoadDeviceCertificate(std::string* cert, std::string* wrapped_key);
  bool StoreLicense(bool active);

  // instance variables
  const CdmSessionId session_id_;
  CdmKeySystem key_system_;
  CdmLicense license_parser_;
  CryptoSession* crypto_session_;
  PolicyEngine policy_engine_;
  bool license_received_;
  bool reinitialize_session_;

  CdmLicenseType license_type_;

  // license type offline related information
  CdmInitData offline_pssh_data_;
  CdmKeyMessage offline_key_request_;
  CdmKeyResponse offline_key_response_;
  CdmKeyMessage offline_key_renewal_request_;
  CdmKeyResponse offline_key_renewal_response_;
  std::string offline_release_server_url_;

  // license type release and offline related information
  CdmKeySetId key_set_id_;

  KeyId key_id_;

  // Used for certificate based licensing
  std::string wrapped_key_;

  std::set<WvCdmEventListener*> listeners_;

  // TODO(kqyang): CdmKey not defined yet
  // CdmSessionKeys session_keys_;

  CORE_DISALLOW_COPY_AND_ASSIGN(CdmSession);
};

}  // namespace wvcdm

#endif  // CDM_BASE_CDM_SESSION_H_