content: /*
   * Copyright (C) 2010 The Android Open Source Project
   *
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   *      http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   */
  
  package android.drm;
  
  import android.content.ContentResolver;
  import android.content.ContentValues;
  import android.content.Context;
  import android.database.Cursor;
  import android.database.sqlite.SQLiteException;
  import android.net.Uri;
  import android.os.Handler;
  import android.os.HandlerThread;
  import android.os.Looper;
  import android.os.Message;
  import android.provider.MediaStore;
  import android.util.Log;
  
  import dalvik.system.CloseGuard;
  
  import java.io.File;
  import java.io.FileDescriptor;
  import java.io.FileInputStream;
  import java.io.IOException;
  import java.lang.ref.WeakReference;
  import java.util.ArrayList;
  import java.util.HashMap;
  import java.util.concurrent.atomic.AtomicBoolean;
  
  /**
   * The main programming interface for the DRM framework. An application must instantiate this class
   * to access DRM agents through the DRM framework.
   *
   */
  public class DrmManagerClient implements AutoCloseable {
      /**
       * Indicates that a request was successful or that no error occurred.
       */
      public static final int ERROR_NONE = 0;
      /**
       * Indicates that an error occurred and the reason is not known.
       */
      public static final int ERROR_UNKNOWN = -2000;
  
      /** {@hide} */
      public static final int INVALID_SESSION = -1;
  
      HandlerThread mInfoThread;
      HandlerThread mEventThread;
      private static final String TAG = "DrmManagerClient";
  
      private final AtomicBoolean mClosed = new AtomicBoolean();
      private final CloseGuard mCloseGuard = CloseGuard.get();
  
      static {
          // Load the respective library
          System.loadLibrary("drmframework_jni");
      }
  
      /**
       * Interface definition for a callback that receives status messages and warnings
       * during registration and rights acquisition.
       */
      public interface OnInfoListener {
          /**
           * Called when the DRM framework sends status or warning information during registration
           * and rights acquisition.
           *
           * @param client The <code>DrmManagerClient</code> instance.
           * @param event The {@link DrmInfoEvent} instance that wraps the status information or 
           * warnings.
           */
          public void onInfo(DrmManagerClient client, DrmInfoEvent event);
      }
  
      /**
       * Interface definition for a callback that receives information
       * about DRM processing events.
       */
      public interface OnEventListener {
          /**
           * Called when the DRM framework sends information about a DRM processing request.
           *
           * @param client The <code>DrmManagerClient</code> instance.
           * @param event The {@link DrmEvent} instance that wraps the information being
           * conveyed, such as the information type and message.
           */
          public void onEvent(DrmManagerClient client, DrmEvent event);
      }
  
      /**
       * Interface definition for a callback that receives information about DRM framework errors.
       */
      public interface OnErrorListener {
          /**
           * Called when the DRM framework sends error information.
           *
           * @param client The <code>DrmManagerClient</code> instance.
           * @param event The {@link DrmErrorEvent} instance that wraps the error type and message.
           */
          public void onError(DrmManagerClient client, DrmErrorEvent event);
      }
  
      private static final int ACTION_REMOVE_ALL_RIGHTS = 1001;
      private static final int ACTION_PROCESS_DRM_INFO = 1002;
  
      private int mUniqueId;
      private long mNativeContext;
      private Context mContext;
      private InfoHandler mInfoHandler;
      private EventHandler mEventHandler;
      private OnInfoListener mOnInfoListener;
      private OnEventListener mOnEventListener;
      private OnErrorListener mOnErrorListener;
  
      private class EventHandler extends Handler {
  
          public EventHandler(Looper looper) {
              super(looper);
          }
  
          public void handleMessage(Message msg) {
              DrmEvent event = null;
              DrmErrorEvent error = null;
              HashMap<String, Object> attributes = new HashMap<String, Object>();
  
              switch(msg.what) {
              case ACTION_PROCESS_DRM_INFO: {
                  final DrmInfo drmInfo = (DrmInfo) msg.obj;
                  DrmInfoStatus status = _processDrmInfo(mUniqueId, drmInfo);
  
                  attributes.put(DrmEvent.DRM_INFO_STATUS_OBJECT, status);
                  attributes.put(DrmEvent.DRM_INFO_OBJECT, drmInfo);
  
                  if (null != status && DrmInfoStatus.STATUS_OK == status.statusCode) {
                      event = new DrmEvent(mUniqueId,
                              getEventType(status.infoType), null, attributes);
                  } else {
                      int infoType = (null != status) ? status.infoType : drmInfo.getInfoType();
                      error = new DrmErrorEvent(mUniqueId,
                              getErrorType(infoType), null, attributes);
                  }
                  break;
              }
              case ACTION_REMOVE_ALL_RIGHTS: {
                  if (ERROR_NONE == _removeAllRights(mUniqueId)) {
                      event = new DrmEvent(mUniqueId, DrmEvent.TYPE_ALL_RIGHTS_REMOVED, null);
                  } else {
                      error = new DrmErrorEvent(mUniqueId,
                              DrmErrorEvent.TYPE_REMOVE_ALL_RIGHTS_FAILED, null);
                  }
                  break;
              }
              default:
                  Log.e(TAG, "Unknown message type " + msg.what);
                  return;
              }
              if (null != mOnEventListener && null != event) {
                  mOnEventListener.onEvent(DrmManagerClient.this, event);
              }
              if (null != mOnErrorListener && null != error) {
                  mOnErrorListener.onError(DrmManagerClient.this, error);
              }
          }
      }
  
      /**
       * {@hide}
       */
      public static void notify(
              Object thisReference, int uniqueId, int infoType, String message) {
          DrmManagerClient instance = (DrmManagerClient)((WeakReference)thisReference).get();
  
          if (null != instance && null != instance.mInfoHandler) {
              Message m = instance.mInfoHandler.obtainMessage(
                  InfoHandler.INFO_EVENT_TYPE, uniqueId, infoType, message);
              instance.mInfoHandler.sendMessage(m);
          }
      }
  
      private class InfoHandler extends Handler {
          public static final int INFO_EVENT_TYPE = 1;
  
          public InfoHandler(Looper looper) {
              super(looper);
          }
  
          public void handleMessage(Message msg) {
              DrmInfoEvent info = null;
              DrmErrorEvent error = null;
  
              switch (msg.what) {
              case InfoHandler.INFO_EVENT_TYPE:
                  int uniqueId = msg.arg1;
                  int infoType = msg.arg2;
                  String message = msg.obj.toString();
  
                  switch (infoType) {
                  case DrmInfoEvent.TYPE_REMOVE_RIGHTS: {
                      try {
                          DrmUtils.removeFile(message);
                      } catch (IOException e) {
                          e.printStackTrace();
                      }
                      info = new DrmInfoEvent(uniqueId, infoType, message);
                      break;
                  }
                  case DrmInfoEvent.TYPE_ALREADY_REGISTERED_BY_ANOTHER_ACCOUNT:
                  case DrmInfoEvent.TYPE_RIGHTS_INSTALLED:
                  case DrmInfoEvent.TYPE_WAIT_FOR_RIGHTS:
                  case DrmInfoEvent.TYPE_ACCOUNT_ALREADY_REGISTERED:
                  case DrmInfoEvent.TYPE_RIGHTS_REMOVED: {
                      info = new DrmInfoEvent(uniqueId, infoType, message);
                      break;
                  }
                  default:
                      error = new DrmErrorEvent(uniqueId, infoType, message);
                      break;
                  }
  
                  if (null != mOnInfoListener && null != info) {
                      mOnInfoListener.onInfo(DrmManagerClient.this, info);
                  }
                  if (null != mOnErrorListener && null != error) {
                      mOnErrorListener.onError(DrmManagerClient.this, error);
                  }
                  return;
              default:
                  Log.e(TAG, "Unknown message type " + msg.what);
                  return;
              }
          }
      }
  
      /**
       * Creates a <code>DrmManagerClient</code>.
       *
       * @param context Context of the caller.
       */
      public DrmManagerClient(Context context) {
          mContext = context;
          createEventThreads();
  
          // save the unique id
          mUniqueId = _initialize();
          mCloseGuard.open("release");
      }
  
      @Override
      protected void finalize() throws Throwable {
          try {
              if (mCloseGuard != null) {
                  mCloseGuard.warnIfOpen();
              }
  
              close();
          } finally {
              super.finalize();
          }
      }
  
      /**
       * Releases resources associated with the current session of
       * DrmManagerClient. It is considered good practice to call this method when
       * the {@link DrmManagerClient} object is no longer needed in your
       * application. After this method is called, {@link DrmManagerClient} is no
       * longer usable since it has lost all of its required resource.
       *
       * This method was added in API 24. In API versions 16 through 23, release()
       * should be called instead. There is no need to do anything for API
       * versions prior to 16.
       */
      @Override
      public void close() {
          mCloseGuard.close();
          if (mClosed.compareAndSet(false, true)) {
              if (mEventHandler != null) {
                  mEventThread.quit();
                  mEventThread = null;
              }
              if (mInfoHandler != null) {
                  mInfoThread.quit();
                  mInfoThread = null;
              }
              mEventHandler = null;
              mInfoHandler = null;
              mOnEventListener = null;
              mOnInfoListener = null;
              mOnErrorListener = null;
              _release(mUniqueId);
          }
      }
  
      /**
       * @deprecated replaced by {@link #close()}.
       */
      @Deprecated
      public void release() {
          close();
      }
  
      /**
       * Registers an {@link DrmManagerClient.OnInfoListener} callback, which is invoked when the 
       * DRM framework sends status or warning information during registration or rights acquisition.
       *
       * @param infoListener Interface definition for the callback.
       */
      public synchronized void setOnInfoListener(OnInfoListener infoListener) {
          mOnInfoListener = infoListener;
          if (null != infoListener) {
              createListeners();
          }
      }
  
      /**
       * Registers an {@link DrmManagerClient.OnEventListener} callback, which is invoked when the 
       * DRM framework sends information about DRM processing.
       *
       * @param eventListener Interface definition for the callback.
       */
      public synchronized void setOnEventListener(OnEventListener eventListener) {
          mOnEventListener = eventListener;
          if (null != eventListener) {
              createListeners();
          }
      }
  
      /**
       * Registers an {@link DrmManagerClient.OnErrorListener} callback, which is invoked when 
       * the DRM framework sends error information.
       *
       * @param errorListener Interface definition for the callback.
       */
      public synchronized void setOnErrorListener(OnErrorListener errorListener) {
          mOnErrorListener = errorListener;
          if (null != errorListener) {
              createListeners();
          }
      }
  
      /**
       * Retrieves information about all the DRM plug-ins (agents) that are registered with
       * the DRM framework.
       *
       * @return A <code>String</code> array of DRM plug-in descriptions.
       */
      public String[] getAvailableDrmEngines() {
          DrmSupportInfo[] supportInfos = _getAllSupportInfo(mUniqueId);
          ArrayList<String> descriptions = new ArrayList<String>();
  
          for (int i = 0; i < supportInfos.length; i++) {
              descriptions.add(supportInfos[i].getDescriprition());
          }
  
          String[] drmEngines = new String[descriptions.size()];
          return descriptions.toArray(drmEngines);
      }
  
      /**
       * Retrieves constraint information for rights-protected content.
       *
       * @param path Path to the content from which you are retrieving DRM constraints.
       * @param action Action defined in {@link DrmStore.Action}.
       *
       * @return A {@link android.content.ContentValues} instance that contains
       * key-value pairs representing the constraints. Null in case of failure.
       * The keys are defined in {@link DrmStore.ConstraintsColumns}.
       */
      public ContentValues getConstraints(String path, int action) {
          if (null == path || path.equals("") || !DrmStore.Action.isValid(action)) {
              throw new IllegalArgumentException("Given usage or path is invalid/null");
          }
          return _getConstraints(mUniqueId, path, action);
      }
  
     /**
      * Retrieves metadata information for rights-protected content.
      *
      * @param path Path to the content from which you are retrieving metadata information.
      *
      * @return A {@link android.content.ContentValues} instance that contains
      * key-value pairs representing the metadata. Null in case of failure.
      */
      public ContentValues getMetadata(String path) {
          if (null == path || path.equals("")) {
              throw new IllegalArgumentException("Given path is invalid/null");
          }
          return _getMetadata(mUniqueId, path);
      }
  
      /**
       * Retrieves constraint information for rights-protected content.
       *
       * @param uri URI for the content from which you are retrieving DRM constraints.
       * @param action Action defined in {@link DrmStore.Action}.
       *
       * @return A {@link android.content.ContentValues} instance that contains
       * key-value pairs representing the constraints. Null in case of failure.
       */
      public ContentValues getConstraints(Uri uri, int action) {
          if (null == uri || Uri.EMPTY == uri) {
              throw new IllegalArgumentException("Uri should be non null");
          }
          return getConstraints(convertUriToPath(uri), action);
      }
  
     /**
      * Retrieves metadata information for rights-protected content.
      *
      * @param uri URI for the content from which you are retrieving metadata information.
      *
      * @return A {@link android.content.ContentValues} instance that contains
      * key-value pairs representing the constraints. Null in case of failure.
      */
      public ContentValues getMetadata(Uri uri) {
          if (null == uri || Uri.EMPTY == uri) {
              throw new IllegalArgumentException("Uri should be non null");
          }
          return getMetadata(convertUriToPath(uri));
      }
  
      /**
       * Saves rights to a specified path and associates that path with the content path.
       * 
       * <p class="note"><strong>Note:</strong> For OMA or WM-DRM, <code>rightsPath</code> and
       * <code>contentPath</code> can be null.</p>
       *
       * @param drmRights The {@link DrmRights} to be saved.
       * @param rightsPath File path where rights will be saved.
       * @param contentPath File path where content is saved.
       *
       * @return ERROR_NONE for success; ERROR_UNKNOWN for failure.
       *
       * @throws IOException If the call failed to save rights information at the given
       * <code>rightsPath</code>.
       */
      public int saveRights(
              DrmRights drmRights, String rightsPath, String contentPath) throws IOException {
          if (null == drmRights || !drmRights.isValid()) {
              throw new IllegalArgumentException("Given drmRights or contentPath is not valid");
          }
          if (null != rightsPath && !rightsPath.equals("")) {
              DrmUtils.writeToFile(rightsPath, drmRights.getData());
          }
          return _saveRights(mUniqueId, drmRights, rightsPath, contentPath);
      }
  
      /**
       * Installs a new DRM plug-in (agent) at runtime.
       *
       * @param engineFilePath File path to the plug-in file to be installed.
       *
       * {@hide}
       */
      public void installDrmEngine(String engineFilePath) {
          if (null == engineFilePath || engineFilePath.equals("")) {
              throw new IllegalArgumentException(
                  "Given engineFilePath: "+ engineFilePath + "is not valid");
          }
          _installDrmEngine(mUniqueId, engineFilePath);
      }
  
      /**
       * Checks whether the given MIME type or path can be handled.
       *
       * @param path Path of the content to be handled.
       * @param mimeType MIME type of the object to be handled.
       *
       * @return True if the given MIME type or path can be handled; false if they cannot be handled.
       */
      public boolean canHandle(String path, String mimeType) {
          if ((null == path || path.equals("")) && (null == mimeType || mimeType.equals(""))) {
              throw new IllegalArgumentException("Path or the mimetype should be non null");
          }
          return _canHandle(mUniqueId, path, mimeType);
      }
  
      /**
       * Checks whether the given MIME type or URI can be handled.
       *
       * @param uri URI for the content to be handled.
       * @param mimeType MIME type of the object to be handled
       *
       * @return True if the given MIME type or URI can be handled; false if they cannot be handled.
       */
      public boolean canHandle(Uri uri, String mimeType) {
          if ((null == uri || Uri.EMPTY == uri) && (null == mimeType || mimeType.equals(""))) {
              throw new IllegalArgumentException("Uri or the mimetype should be non null");
          }
          return canHandle(convertUriToPath(uri), mimeType);
      }
  
      /**
       * Processes the given DRM information based on the information type.
       *
       * @param drmInfo The {@link DrmInfo} to be processed.
       * @return ERROR_NONE for success; ERROR_UNKNOWN for failure.
       */
      public int processDrmInfo(DrmInfo drmInfo) {
          if (null == drmInfo || !drmInfo.isValid()) {
              throw new IllegalArgumentException("Given drmInfo is invalid/null");
          }
          int result = ERROR_UNKNOWN;
          if (null != mEventHandler) {
              Message msg = mEventHandler.obtainMessage(ACTION_PROCESS_DRM_INFO, drmInfo);
              result = (mEventHandler.sendMessage(msg)) ? ERROR_NONE : result;
          }
          return result;
      }
  
      /**
       * Retrieves information for registering, unregistering, or acquiring rights.
       *
       * @param drmInfoRequest The {@link DrmInfoRequest} that specifies the type of DRM
       * information being retrieved.
       *
       * @return A {@link DrmInfo} instance.
       */
      public DrmInfo acquireDrmInfo(DrmInfoRequest drmInfoRequest) {
          if (null == drmInfoRequest || !drmInfoRequest.isValid()) {
              throw new IllegalArgumentException("Given drmInfoRequest is invalid/null");
          }
          return _acquireDrmInfo(mUniqueId, drmInfoRequest);
      }
  
      /**
       * Processes a given {@link DrmInfoRequest} and returns the rights information asynchronously.
       *<p>
       * This is a utility method that consists of an
       * {@link #acquireDrmInfo(DrmInfoRequest) acquireDrmInfo()} and a
       * {@link #processDrmInfo(DrmInfo) processDrmInfo()} method call. This utility method can be 
       * used only if the selected DRM plug-in (agent) supports this sequence of calls. Some DRM
       * agents, such as OMA, do not support this utility method, in which case an application must
       * invoke {@link #acquireDrmInfo(DrmInfoRequest) acquireDrmInfo()} and
       * {@link #processDrmInfo(DrmInfo) processDrmInfo()} separately.
       *
       * @param drmInfoRequest The {@link DrmInfoRequest} used to acquire the rights.
       * @return ERROR_NONE for success; ERROR_UNKNOWN for failure.
       */
      public int acquireRights(DrmInfoRequest drmInfoRequest) {
          DrmInfo drmInfo = acquireDrmInfo(drmInfoRequest);
          if (null == drmInfo) {
              return ERROR_UNKNOWN;
          }
          return processDrmInfo(drmInfo);
      }
  
      /**
       * Retrieves the type of rights-protected object (for example, content object, rights
       * object, and so on) using the specified path or MIME type. At least one parameter must
       * be specified to retrieve the DRM object type.
       *
       * @param path Path to the content or null.
       * @param mimeType MIME type of the content or null.
       * 
       * @return An <code>int</code> that corresponds to a {@link DrmStore.DrmObjectType}.
       */
      public int getDrmObjectType(String path, String mimeType) {
          if ((null == path || path.equals("")) && (null == mimeType || mimeType.equals(""))) {
              throw new IllegalArgumentException("Path or the mimetype should be non null");
          }
          return _getDrmObjectType(mUniqueId, path, mimeType);
      }
  
      /**
       * Retrieves the type of rights-protected object (for example, content object, rights
       * object, and so on) using the specified URI or MIME type. At least one parameter must
       * be specified to retrieve the DRM object type.
       *
       * @param uri URI for the content or null.
       * @param mimeType MIME type of the content or null.
       * 
       * @return An <code>int</code> that corresponds to a {@link DrmStore.DrmObjectType}.
       */
      public int getDrmObjectType(Uri uri, String mimeType) {
          if ((null == uri || Uri.EMPTY == uri) && (null == mimeType || mimeType.equals(""))) {
              throw new IllegalArgumentException("Uri or the mimetype should be non null");
          }
          String path = "";
          try {
              path = convertUriToPath(uri);
          } catch (Exception e) {
              // Even uri is invalid the mimetype shall be valid, so allow to proceed further.
              Log.w(TAG, "Given Uri could not be found in media store");
          }
          return getDrmObjectType(path, mimeType);
      }
  
      /**
       * Retrieves the MIME type embedded in the original content.
       *
       * @param path Path to the rights-protected content.
       *
       * @return The MIME type of the original content, such as <code>video/mpeg</code>.
       */
      public String getOriginalMimeType(String path) {
          if (null == path || path.equals("")) {
              throw new IllegalArgumentException("Given path should be non null");
          }
  
          String mime = null;
  
          FileInputStream is = null;
          try {
              FileDescriptor fd = null;
              File file = new File(path);
              if (file.exists()) {
                  is = new FileInputStream(file);
                  fd = is.getFD();
              }
              mime = _getOriginalMimeType(mUniqueId, path, fd);
          } catch (IOException ioe) {
          } finally {
              if (is != null) {
                  try {
                      is.close();
                  } catch(IOException e) {}
              }
          }
  
          return mime;
      }
  
      /**
       * Retrieves the MIME type embedded in the original content.
       *
       * @param uri URI of the rights-protected content.
       *
       * @return MIME type of the original content, such as <code>video/mpeg</code>.
       */
      public String getOriginalMimeType(Uri uri) {
          if (null == uri || Uri.EMPTY == uri) {
              throw new IllegalArgumentException("Given uri is not valid");
          }
          return getOriginalMimeType(convertUriToPath(uri));
      }
  
      /**
       * Checks whether the given content has valid rights.
       *
       * @param path Path to the rights-protected content.
       *
       * @return An <code>int</code> representing the {@link DrmStore.RightsStatus} of the content.
       */
      public int checkRightsStatus(String path) {
          return checkRightsStatus(path, DrmStore.Action.DEFAULT);
      }
  
      /**
       * Check whether the given content has valid rights.
       *
       * @param uri URI of the rights-protected content.
       *
       * @return An <code>int</code> representing the {@link DrmStore.RightsStatus} of the content.
       */
      public int checkRightsStatus(Uri uri) {
          if (null == uri || Uri.EMPTY == uri) {
              throw new IllegalArgumentException("Given uri is not valid");
          }
          return checkRightsStatus(convertUriToPath(uri));
      }
  
      /**
       * Checks whether the given rights-protected content has valid rights for the specified
       * {@link DrmStore.Action}.
       *
       * @param path Path to the rights-protected content.
       * @param action The {@link DrmStore.Action} to perform.
       *
       * @return An <code>int</code> representing the {@link DrmStore.RightsStatus} of the content.
       */
      public int checkRightsStatus(String path, int action) {
          if (null == path || path.equals("") || !DrmStore.Action.isValid(action)) {
              throw new IllegalArgumentException("Given path or action is not valid");
          }
          return _checkRightsStatus(mUniqueId, path, action);
      }
  
      /**
       * Checks whether the given rights-protected content has valid rights for the specified
       * {@link DrmStore.Action}.
       *
       * @param uri URI for the rights-protected content.
       * @param action The {@link DrmStore.Action} to perform.
       *
       * @return An <code>int</code> representing the {@link DrmStore.RightsStatus} of the content.
       */
      public int checkRightsStatus(Uri uri, int action) {
          if (null == uri || Uri.EMPTY == uri) {
              throw new IllegalArgumentException("Given uri is not valid");
          }
          return checkRightsStatus(convertUriToPath(uri), action);
      }
  
      /**
       * Removes the rights associated with the given rights-protected content.
       *
       * @param path Path to the rights-protected content.
       *
       * @return ERROR_NONE for success; ERROR_UNKNOWN for failure.
       */
      public int removeRights(String path) {
          if (null == path || path.equals("")) {
              throw new IllegalArgumentException("Given path should be non null");
          }
          return _removeRights(mUniqueId, path);
      }
  
      /**
       * Removes the rights associated with the given rights-protected content.
       *
       * @param uri URI for the rights-protected content.
       *
       * @return ERROR_NONE for success; ERROR_UNKNOWN for failure.
       */
      public int removeRights(Uri uri) {
          if (null == uri || Uri.EMPTY == uri) {
              throw new IllegalArgumentException("Given uri is not valid");
          }
          return removeRights(convertUriToPath(uri));
      }
  
      /**
       * Removes all the rights information of every DRM plug-in (agent) associated with
       * the DRM framework. Will be used during a master reset.
       *
       * @return ERROR_NONE for success; ERROR_UNKNOWN for failure.
       */
      public int removeAllRights() {
          int result = ERROR_UNKNOWN;
          if (null != mEventHandler) {
              Message msg = mEventHandler.obtainMessage(ACTION_REMOVE_ALL_RIGHTS);
              result = (mEventHandler.sendMessage(msg)) ? ERROR_NONE : result;
          }
          return result;
      }
  
      /**
       * Initiates a new conversion session. An application must initiate a conversion session
       * with this method each time it downloads a rights-protected file that needs to be converted.
       *<p>
       * This method applies only to forward-locking (copy protection) DRM schemes.
       *
       * @param mimeType MIME type of the input data packet.
       *
       * @return A convert ID that is used used to maintain the conversion session.
       */
      public int openConvertSession(String mimeType) {
          if (null == mimeType || mimeType.equals("")) {
              throw new IllegalArgumentException("Path or the mimeType should be non null");
          }
          return _openConvertSession(mUniqueId, mimeType);
      }
  
      /**
       * Converts the input data (content) that is part of a rights-protected file. The converted
       * data and status is returned in a {@link DrmConvertedStatus} object. This method should be
       * called each time there is a new block of data received by the application.
       *
       * @param convertId Handle for the conversion session.
       * @param inputData Input data that needs to be converted.
       *
       * @return A {@link DrmConvertedStatus} object that contains the status of the data conversion,
       * the converted data, and offset for the header and body signature. An application can 
       * ignore the offset because it is only relevant to the
       * {@link #closeConvertSession closeConvertSession()} method.
       */
      public DrmConvertedStatus convertData(int convertId, byte[] inputData) {
          if (null == inputData || 0 >= inputData.length) {
              throw new IllegalArgumentException("Given inputData should be non null");
          }
          return _convertData(mUniqueId, convertId, inputData);
      }
  
      /**
       * Informs the DRM plug-in (agent) that there is no more data to convert or that an error 
       * has occurred. Upon successful conversion of the data, the DRM agent will provide an offset
       * value indicating where the header and body signature should be added. Appending the 
       * signature is necessary to protect the integrity of the converted file.
       *
       * @param convertId Handle for the conversion session.
       *
       * @return A {@link DrmConvertedStatus} object that contains the status of the data conversion,
       * the converted data, and the offset for the header and body signature.
       */
      public DrmConvertedStatus closeConvertSession(int convertId) {
          return _closeConvertSession(mUniqueId, convertId);
      }
  
      private int getEventType(int infoType) {
          int eventType = -1;
  
          switch (infoType) {
          case DrmInfoRequest.TYPE_REGISTRATION_INFO:
          case DrmInfoRequest.TYPE_UNREGISTRATION_INFO:
          case DrmInfoRequest.TYPE_RIGHTS_ACQUISITION_INFO:
              eventType = DrmEvent.TYPE_DRM_INFO_PROCESSED;
              break;
          }
          return eventType;
      }
  
      private int getErrorType(int infoType) {
          int error = -1;
  
          switch (infoType) {
          case DrmInfoRequest.TYPE_REGISTRATION_INFO:
          case DrmInfoRequest.TYPE_UNREGISTRATION_INFO:
          case DrmInfoRequest.TYPE_RIGHTS_ACQUISITION_INFO:
              error = DrmErrorEvent.TYPE_PROCESS_DRM_INFO_FAILED;
              break;
          }
          return error;
      }
  
      /**
       * This method expects uri in the following format
       *     content://media/<table_name>/<row_index> (or)
       *     file://sdcard/test.mp4
       *     http://test.com/test.mp4
       *     https://test.com/test.mp4
       *
       * Here <table_name> shall be "video" or "audio" or "images"
       * <row_index> the index of the content in given table
       */
      private String convertUriToPath(Uri uri) {
          String path = null;
          if (null != uri) {
              String scheme = uri.getScheme();
              if (null == scheme || scheme.equals("") ||
                      scheme.equals(ContentResolver.SCHEME_FILE)) {
                  path = uri.getPath();
  
              } else if (scheme.equals("http") || scheme.equals("https")) {
                  path = uri.toString();
  
              } else if (scheme.equals(ContentResolver.SCHEME_CONTENT)) {
                  String[] projection = new String[] {MediaStore.MediaColumns.DATA};
                  Cursor cursor = null;
                  try {
                      cursor = mContext.getContentResolver().query(uri, projection, null,
                              null, null);
                      if (null == cursor || 0 == cursor.getCount() || !cursor.moveToFirst()) {
                          throw new IllegalArgumentException("Given Uri could not be found" +
                                  " in media store");
                      }
                      int pathIndex = cursor.getColumnIndexOrThrow(MediaStore.MediaColumns.DATA);
                      path = cursor.getString(pathIndex);
                  } catch (SQLiteException e) {
                      throw new IllegalArgumentException("Given Uri is not formatted in a way " +
                              "so that it can be found in media store.");
                  } finally {
                      if (null != cursor) {
                          cursor.close();
                      }
                  }
              } else {
                  throw new IllegalArgumentException("Given Uri scheme is not supported");
              }
          }
          return path;
      }
  
      // private native interfaces
      private native int _initialize();
  
      private native void _setListeners(int uniqueId, Object weak_this);
  
      private native void _release(int uniqueId);
  
      private native void _installDrmEngine(int uniqueId, String engineFilepath);
  
      private native ContentValues _getConstraints(int uniqueId, String path, int usage);
  
      private native ContentValues _getMetadata(int uniqueId, String path);
  
      private native boolean _canHandle(int uniqueId, String path, String mimeType);
  
      private native DrmInfoStatus _processDrmInfo(int uniqueId, DrmInfo drmInfo);
  
      private native DrmInfo _acquireDrmInfo(int uniqueId, DrmInfoRequest drmInfoRequest);
  
      private native int _saveRights(
              int uniqueId, DrmRights drmRights, String rightsPath, String contentPath);
  
      private native int _getDrmObjectType(int uniqueId, String path, String mimeType);
  
      private native String _getOriginalMimeType(int uniqueId, String path, FileDescriptor fd);
  
      private native int _checkRightsStatus(int uniqueId, String path, int action);
  
      private native int _removeRights(int uniqueId, String path);
  
      private native int _removeAllRights(int uniqueId);
  
      private native int _openConvertSession(int uniqueId, String mimeType);
  
      private native DrmConvertedStatus _convertData(
              int uniqueId, int convertId, byte[] inputData);
  
      private native DrmConvertedStatus _closeConvertSession(int uniqueId, int convertId);
  
      private native DrmSupportInfo[] _getAllSupportInfo(int uniqueId);
  
      private void createEventThreads() {
          if (mEventHandler == null && mInfoHandler == null) {
              mInfoThread = new HandlerThread("DrmManagerClient.InfoHandler");
              mInfoThread.start();
              mInfoHandler = new InfoHandler(mInfoThread.getLooper());
  
              mEventThread = new HandlerThread("DrmManagerClient.EventHandler");
              mEventThread.start();
              mEventHandler = new EventHandler(mEventThread.getLooper());
          }
      }
  
      private void createListeners() {
          _setListeners(mUniqueId, new WeakReference<DrmManagerClient>(this));
      }
  }
  
  