Exemples de code Android

Important

Les versions du Kit de développement logiciel (SDK) du service Microsoft Rights Management publiées avant mars 2020 sont déconseillées ; les applications utilisant des versions antérieures doivent être mises à jour pour utiliser la version de mars 2020. Pour plus d’informations, consultez l’avis d'obsolescence.

Aucune autre amélioration n’est prévue pour le Kit de développement logiciel (SDK) du service Microsoft Rights Management. Nous recommandons vivement d'adopter le SDK de protection des informations Microsoft pour les services de classification, d'étiquetage et de protection.

Cet article explique comment coder des éléments pour la version Android du Kit de développement logiciel (SDK) RMS.

Note Dans cet article, le terme MSIPC (Microsoft Information Protection and Control) fait référence au processus client.

Utilisation du Kit de développement logiciel (SDK) Microsoft Rights Management 4.2 - scénarios clés

Ces exemples de code sont extraits d’un exemple d’application plus large représentant des scénarios de développement importants pour votre orientation vers ce Kit de développement logiciel (SDK). Ils montrent comment utiliser :

• Le format de fichier protégé Microsoft, également appelé fichier protégé.
• Formats de fichiers protégés personnalisés
• Contrôles d’interface utilisateur personnalisés

L’exemple d’application MSIPCSampleApp est disponible pour une utilisation avec ce Kit de développement logiciel (SDK) pour le système d’exploitation Android. Pour en savoir plus, consultez rms-sdk-ui-for-android.

Scénario : Consommer un fichier protégé RMS

• Étape 1 : Créer un ProtectedFileInputStream.

  Source : MsipcAuthenticationCallback.java

  Description : instanciez un objet ProtectedFileInputStream et implémentez l’authentification du service. Utilisez AuthenticationRequestCallback pour obtenir un jeton en passant une instance d’AuthenticationRequestCallback, en tant que paramètre mRmsAuthCallback, à l’API MSIPC. Consultez l’appel à ProtectedFileInputStream.create à la fin de l’exemple de code suivant.

      public void startContentConsumptionFromPtxtFileFormat(InputStream inputStream)
      {
          CreationCallback<ProtectedFileInputStream> protectedFileInputStreamCreationCallback =
            new CreationCallback<ProtectedFileInputStream>()
          {
              @Override
              public Context getContext()
              {
                 …
             }
  
              @Override
              public void onCancel()
              {
                 …
              }
  
              @Override
              public void onFailure(ProtectionException e)
              {
                 …
              }
  
              @Override
              public void onSuccess(ProtectedFileInputStream protectedFileInputStream)
              {
                 …
                 …
                  byte[] dataChunk = new byte[16384];
                  try
                  {
                      while ((nRead = protectedFileInputStream.read(dataChunk, 0,
                              dataChunk.length)) != -1)
                      {
                          …
                      }
                       …
                      protectedFileInputStream.close();
                  }
                  catch (IOException e)
                  {
                    …
                  }
            }
          };
          try
          {
             …
              ProtectedFileInputStream.create(inputStream, null, mRmsAuthCallback,
                                              PolicyAcquisitionFlags.NONE,
                                              protectedFileInputStreamCreationCallback);
          }
          catch (com.microsoft.rightsmanagement.exceptions.InvalidParameterException e)
          {
              …
          }
      }
  

• Étape 2 : Configurer l’authentification à l’aide de la bibliothèque d’authentification Active Directory (ADAL).

  Source : MsipcAuthenticationCallback.java.

  Description : cette étape utilise ADAL pour implémenter un AuthenticationRequestCallback avec des exemples de paramètres d’authentification. Pour en savoir plus, consultez la bibliothèque d’authentification Azure AD (ADAL).

       class MsipcAuthenticationCallback implements AuthenticationRequestCallback
       {
  
       …
  
       @Override
       public void getToken(Map<String, String> authenticationParametersMap,
                            final AuthenticationCompletionCallback authenticationCompletionCallbackToMsipc)
       {
           String authority = authenticationParametersMap.get("oauth2.authority");
           String resource = authenticationParametersMap.get("oauth2.resource");
           String userId = authenticationParametersMap.get("userId");
           final String userHint = (userId == null)? "" : userId;
           AuthenticationContext authenticationContext = App.getInstance().getAuthenticationContext();
           if (authenticationContext == null || !authenticationContext.getAuthority().equalsIgnoreCase(authority))
           {
               try
               {
                   authenticationContext = new AuthenticationContext(App.getInstance().getApplicationContext(), authority, …);
                   App.getInstance().setAuthenticationContext(authenticationContext);
               }
               catch (NoSuchAlgorithmException e)
               {
                   …
                   authenticationCompletionCallbackToMsipc.onFailure();
               }
               catch (NoSuchPaddingException e)
               {
                   …
                   authenticationCompletionCallbackToMsipc.onFailure();
               }
          }
           App.getInstance().getAuthenticationContext().acquireToken(mParentActivity, resource, mClientId, mRedirectURI, userId, mPromptBehavior,
                          "&USERNAME=" + userHint, new AuthenticationCallback<AuthenticationResult>()
                           {
                               @Override
                               public void onError(Exception exc)
                               {
                                   …
                                   if (exc instanceof AuthenticationCancelError)
                                   {
                                        …
                                       authenticationCompletionCallbackToMsipc.onCancel();
                                   }
                                   else
                                   {
                                        …
                                       authenticationCompletionCallbackToMsipc.onFailure();
                                   }
                               }
  
                               @Override
                               public void onSuccess(AuthenticationResult result)
                               {
                                   …
                                   if (result == null || result.getAccessToken() == null
                                           || result.getAccessToken().isEmpty())
                                   {
                                        …
                                   }
                                   else
                                   {
                                       // request is successful
                                       …
                                       authenticationCompletionCallbackToMsipc.onSuccess(result.getAccessToken());
                                   }
                               }
                           }
  
                           );
                     }
  

• Étape 3 : Vérifiez si le droit Modifier existe pour cet utilisateur avec ce contenu via la méthode UserPolicy.accessCheck .

  Source : TextEditorFragment.java

       //check if user has edit rights and apply enforcements
              if (!mUserPolicy.accessCheck(EditableDocumentRights.Edit))
              {
                  mTextEditor.setFocusableInTouchMode(false);
                  mTextEditor.setFocusable(false);
                  mTextEditor.setEnabled(false);
                  …
              }
  

Scénario : Créer un fichier protégé à l’aide d’un modèle

Ce scénario commence par obtenir une liste de modèles, en sélectionnant le premier pour créer une stratégie, puis crée et écrit dans le nouveau fichier protégé.

• Étape 1 : Obtenir la liste des modèles via un objet TemplateDescriptor .

  Source : MsipcTaskFragment.java

  CreationCallback<List<TemplateDescriptor>> getTemplatesCreationCallback = new CreationCallback<List<TemplateDescriptor>>()
    {
        @Override
        public Context getContext()
        {
            …
        }
  
        @Override
        public void onCancel()
        {
            …
        }
  
        @Override
        public void onFailure(ProtectionException e)
        {
            …
        }
  
        @Override
        public void onSuccess(List<TemplateDescriptor> templateDescriptors)
        {
           …
        }
    };
    try
    {
            …
        mIAsyncControl = TemplateDescriptor.getTemplates(emailId, mRmsAuthCallback, getTemplatesCreationCallback);
    }
    catch (com.microsoft.rightsmanagement.exceptions.InvalidParameterException e)
    {
            …
    }
  

• Étape 2 : Créez une stratégie UserPolicy à l’aide du premier modèle de la liste.

  Source : MsipcTaskFragment.java

    CreationCallback<UserPolicy> userPolicyCreationCallback = new CreationCallback<UserPolicy>()
    {
        @Override
        public Context getContext()
        {
            …
        }
  
        @Override
        public void onCancel()
        {
            …
        }
  
        @Override
        public void onFailure(ProtectionException e)
        {
            …
        }
  
        @Override
        public void onSuccess(final UserPolicy item)
        {
            …
        }
    };
    try
    {
         …
        mIAsyncControl = UserPolicy.create((TemplateDescriptor)selectedDescriptor, mEmailId, mRmsAuthCallback,
                          UserPolicyCreationFlags.NONE, userPolicyCreationCallback);
         …
    }
    catch (InvalidParameterException e)
    {
            …
    }
  

• Étape 3 : Créez un ProtectedFileOutputStream et écrivez-y du contenu.

  Source : MsipcTaskFragment.java

  private void createPTxt(final byte[] contentToProtect)
      {
           …
          CreationCallback<ProtectedFileOutputStream> protectedFileOutputStreamCreationCallback = new CreationCallback<ProtectedFileOutputStream>()
          {
              @Override
              public Context getContext()
              {
               …
              }
  
              @Override
              public void onCancel()
              {
               …
              }
  
              @Override
              public void onFailure(ProtectionException e)
              {
               …
              }
  
              @Override
              public void onSuccess(ProtectedFileOutputStream protectedFileOutputStream)
              {
                  try
                  {
                      // write to this stream
                      protectedFileOutputStream.write(contentToProtect);
                      protectedFileOutputStream.flush();
                      protectedFileOutputStream.close();
                      …
                  }
                  catch (IOException e)
                  {
                      …
                  }
              }
          };
          try
          {
              File file = new File(filePath);
              outputStream = new FileOutputStream(file);
              mIAsyncControl = ProtectedFileOutputStream.create(outputStream, mUserPolicy, originalFileExtension,
                      protectedFileOutputStreamCreationCallback);
          }
          catch (FileNotFoundException e)
          {
               …
          }
          catch (InvalidParameterException e)
          {
               …
          }
      }
  

Scénario : Ouvrir un fichier protégé personnalisé

• Étape 1 : Créer une stratégie UserPolicy à partir d’une stratégie sérialiséeContentPolicy.

  Source : MsipcTaskFragment.java

  CreationCallback<UserPolicy> userPolicyCreationCallbackFromSerializedContentPolicy = new CreationCallback<UserPolicy>()
          {
              @Override
              public void onSuccess(UserPolicy userPolicy)
              {
                …
              }
  
              @Override
              public void onFailure(ProtectionException e)
              {
                …
              }
  
              @Override
              public void onCancel()
              {
                …
              }
  
              @Override
              public Context getContext()
              {
                …
              }
          };
          try
          {
              ...
  
              // Read the serializedContentPolicyLength from the inputStream.
              long serializedContentPolicyLength = readUnsignedInt(inputStream);
  
              // Read the PL bytes from the input stream using the PL size.
              byte[] serializedContentPolicy = new byte[(int)serializedContentPolicyLength];
              inputStream.read(serializedContentPolicy);
  
              ...
  
              UserPolicy.acquire(serializedContentPolicy, null, mRmsAuthCallback, PolicyAcquisitionFlags.NONE,
              userPolicyCreationCallbackFromSerializedContentPolicy);
          }
          catch (com.microsoft.rightsmanagement.exceptions.InvalidParameterException e)
          {
          ...
          }
          catch (IOException e)
          {
          ...
          }
  

• Étape 2 : Créez un CustomProtectedInputStream à l’aide de UserPolicy à l’étape 1.

  Source : MsipcTaskFragment.java

    CreationCallback<CustomProtectedInputStream> customProtectedInputStreamCreationCallback = new CreationCallback<CustomProtectedInputStream>()
    {
       @Override
       public Context getContext()
       {
           …
       }
  
       @Override
       public void onCancel()
       {
           …
       }
  
       @Override
       public void onFailure(ProtectionException e)
       {
           …
       }
  
       @Override
       public void onSuccess(CustomProtectedInputStream customProtectedInputStream)
       {
          …
  
           byte[] dataChunk = new byte[16384];
           try
           {
               while ((nRead = customProtectedInputStream.read(dataChunk, 0, dataChunk.length)) != -1)
               {
                    …
               }
                …
               customProtectedInputStream.close();
           }
           catch (IOException e)
           {
              …
           }
           …
       }
   };
  
  try
  {
    ...
  
    // Retrieve the encrypted content size.
    long encryptedContentLength = readUnsignedInt(inputStream);
  
    updateTaskStatus(new TaskStatus(TaskState.Starting, "Consuming content", true));
  
    CustomProtectedInputStream.create(userPolicy, inputStream,
                                   encryptedContentLength,
                                   customProtectedInputStreamCreationCallback);
  }
  catch (com.microsoft.rightsmanagement.exceptions.InvalidParameterException e)
  {
    ...
  }
  catch (IOException e)
  {
    ...
  }
  

• Étape 3 : Lire le contenu de CustomProtectedInputStream dans mDecryptedContent , puis fermer.

  Source : MsipcTaskFragment.java

  @Override
  public void onSuccess(CustomProtectedInputStream customProtectedInputStream)
  {
    mUserPolicy = customProtectedInputStream.getUserPolicy();
    ByteArrayOutputStream buffer = new ByteArrayOutputStream();
  
    int nRead;
    byte[] dataChunk = new byte[16384];
  
    try
    {
      while ((nRead = customProtectedInputStream.read(dataChunk, 0,
                                                          dataChunk.length)) != -1)
      {
         buffer.write(dataChunk, 0, nRead);
      }
  
      buffer.flush();
      mDecryptedContent = new String(buffer.toByteArray(), Charset.forName("UTF-8"));
  
      buffer.close();
      customProtectedInputStream.close();
    }
    catch (IOException e)
    {
      ...
    }
  }
  

Scénario : Créer un fichier protégé personnalisé à l’aide d’une stratégie personnalisée

• étape 1: avec une adresse e-mail fournie par l’utilisateur, créez un descripteur de stratégie.

  Source : MsipcTaskFragment.java

  Description : Dans la pratique, les objets suivants sont créés à l’aide d’entrées utilisateur à partir de l’interface de l’appareil ; UserRights et PolicyDescriptor.

    // create userRights list
    UserRights userRights = new UserRights(Arrays.asList("consumer@domain.com"),
      Arrays.asList( CommonRights.View, EditableDocumentRights.Print));
    ArrayList<UserRights> usersRigthsList = new ArrayList<UserRights>();
    usersRigthsList.add(userRights);
  
    // Create PolicyDescriptor using userRights list
    PolicyDescriptor policyDescriptor = PolicyDescriptor.createPolicyDescriptorFromUserRights(
                                                           usersRigthsList);
    policyDescriptor.setOfflineCacheLifetimeInDays(10);
    policyDescriptor.setContentValidUntil(new Date());
  

• Étape 2 : Créez une userPolicy personnalisée à partir du descripteur de stratégie, selectedDescriptor.

  Source : MsipcTaskFragment.java

     mIAsyncControl = UserPolicy.create((PolicyDescriptor)selectedDescriptor,
       mEmailId, mRmsAuthCallback, UserPolicyCreationFlags.NONE, userPolicyCreationCallback);
  

• Étape 3 : Créer et écrire du contenu dans CustomProtectedOutputStream , puis fermer.

  Source : MsipcTaskFragment.java

  File file = new File(filePath);
      final OutputStream outputStream = new FileOutputStream(file);
      CreationCallback<CustomProtectedOutputStream> customProtectedOutputStreamCreationCallback = new CreationCallback<CustomProtectedOutputStream>()
      {
          @Override
          public Context getContext()
          {
            …
          }
  
          @Override
          public void onCancel()
          {
            …
          }
  
          @Override
          public void onFailure(ProtectionException e)
          {
            …
          }
  
          @Override
          public void onSuccess(CustomProtectedOutputStream protectedOutputStream)
          {
              try
              {
                  // write serializedContentPolicy
                  byte[] serializedContentPolicy = mUserPolicy.getSerializedContentPolicy();
                  writeLongAsUnsignedIntToStream(outputStream, serializedContentPolicy.length);
                  outputStream.write(serializedContentPolicy);
                  // write encrypted content
                  if (contentToProtect != null)
                  {
                      writeLongAsUnsignedIntToStream(outputStream,
                              CustomProtectedOutputStream.getEncryptedContentLength(contentToProtect.length,
                                      protectedOutputStream.getUserPolicy()));
                      protectedOutputStream.write(contentToProtect);
                      protectedOutputStream.flush();
                      protectedOutputStream.close();
                  }
                  else
                  {
                      outputStream.flush();
                      outputStream.close();
                  }
                  …
              }
              catch (IOException e)
              {
                …
              }
          }
      };
      try
      {
          mIAsyncControl = CustomProtectedOutputStream.create(outputStream, mUserPolicy,
                  customProtectedOutputStreamCreationCallback);
      }
      catch (InvalidParameterException e)
      {
        …
      }