Cette page a été traduite par l'API Cloud Translation.

Créer une application de prise de notes

La prise de notes est une fonctionnalité essentielle d'Android qui améliore la productivité des utilisateurs appareils à grand écran. Les applications de prise de notes permettent aux utilisateurs d'écrire et de dessiner une fenêtre flottante ou en plein écran, capturer et annoter le contenu de l'écran ; et enregistrez des notes pour les revoir et les réviser ultérieurement.

Les utilisateurs peuvent accéder aux applications de prise de notes depuis l'écran de verrouillage ou en exécutant d'autres applications.

La compatibilité avec le stylet pour la prise de notes offre une expérience exceptionnelle à l'utilisateur.

Rôle "Notes"

La RoleManager.ROLE_NOTES identifie les applications de prise de notes et leur attribue le rôle LAUNCH_CAPTURE_CONTENT_ACTIVITY_FOR_NOTE l'autorisation.

Pour obtenir le rôle "Notes" pour votre application, procédez comme suit :

Appeler isRoleAvailable() pour vérifier l'état du rôle.
Si le rôle "Notes" est disponible, appelez createRequestRoleIntent() pour obtenir un intent spécifique aux notes.
Appeler startActivityForResult() avec l'intent "Notes" pour inviter l'utilisateur à attribuer le rôle "Notes" à votre l'application.

Une seule application peut disposer du rôle "Notes".

L'application s'ouvre en réponse à une commande ACTION_CREATE_NOTE une action d'intent. Si elle est appelée depuis l'écran de verrouillage de l'appareil, l'application s'ouvre entièrement écran si elle est appelée lorsque l'écran est déverrouillé, dans une fenêtre flottante.

Fichier manifeste d'application

Pour bénéficier du rôle "Notes", votre application doit inclure la déclaration suivante dans le fichier manifeste de l'application:

<activity
    android:name="YourActivityName"
    android:exported="true"
    android:showWhenLocked="true"
    android:turnScreenOn="true">
    <intent-filter>
        <action android:name="android.intent.action.CREATE_NOTE" />
        <category android:name="android.intent.category.DEFAULT" />
    </intent-filter>
</activity>

Cette déclaration permet aux utilisateurs d'attribuer le rôle "Notes" à votre application. l'application de prise de notes par défaut:

ACTION_CREATE_NOTE définit l'action d'intent à laquelle votre application répond
showWhenLocked rend votre application accessible depuis l'écran de verrouillage de l'appareil
turnScreenOn active votre application pour allumer l'écran de l'appareil lorsque l'application s'exécute

Caractéristiques des applications

Une application de prise de notes différenciée sur grand écran offre une complémentarité complète de fonctionnalités de prise de notes.

Compatible avec les stylets

Lorsque votre application est appelée avec la méthode EXTRA_USE_STYLUS_MODE intent supplémentaire défini sur true, l'application doit ouvrir une note compatible avec le stylet (ou au toucher).

Si l'intent supplémentaire est défini sur false, votre application doit ouvrir une note qui accepte saisie au clavier.

Accès à l'écran de verrouillage

Votre application doit fournir une activité en plein écran qui s'exécute lorsqu'elle est ouvert à partir de l'écran de verrouillage de l'appareil.

Votre application ne doit afficher l'historique des notes que si l'utilisateur a donné son consentement (dans les l'état de l'appareil déverrouillé) à l'affichage des anciennes notes. Dans le cas contraire, si l'application est ouverte depuis l'écran de verrouillage, votre application doit toujours créer une nouvelle note.

Vous pouvez vérifier si votre application a été lancée depuis l'écran de verrouillage avec KeyguardManager#isKeyguardLocked() Pour demander à l'utilisateur de s'authentifier et de déverrouiller l'appareil, appelez KeyguardManager#requestDismissKeyguard():

Kotlin

val keyguardManager =
getSystemService(KEYGUARD_SERVICE) as KeyguardManager
keyguardManager.requestDismissKeyguard(  this, object :
KeyguardDismissCallback() {  override fun onDismissError() {  // Unlock failed.
Dismissing keyguard is not feasible.  }  override fun onDismissSucceeded() {  //
Unlock succeeded. Device is now unlocked.  }  override fun onDismissCancelled()
{  // Unlock failed. User cancelled operation or request otherwise cancelled.  }
 } )

Java

KeyguardManager keyguardManager = (KeyguardManager) getSystemService(KEYGUARD_SERVICE);

boolean isLocked = keyguardManager.isKeyguardLocked();

keyguardManager.requestDismissKeyguard(
    this,
    new KeyguardManager.KeyguardDismissCallback() {

  @Override
  public void onDismissError() {
      // Unlock failed. Dismissing keyguard is not feasible.
  }

  @Override
  public void onDismissSucceeded() {
      // Unlock succeeded. Device is now unlocked.
  }

  @Override
  public void onDismissCancelled() {
      // Unlock failed. User cancelled operation or request otherwise cancelled.
  }
});

Fenêtres flottantes

Pour la prise de notes contextuelle, votre application doit fournir une activité qui s'ouvre dans un flottante lorsqu'une autre application est en cours d'exécution.

Votre application doit prendre en charge multi-instance afin que les utilisateurs puissent créer plusieurs notes dans plusieurs fenêtres flottantes, Lorsque votre application de prise de notes est lancée en plein écran ou en écran partagé .

Capture de contenu

La capture de contenu est une fonctionnalité essentielle des applications de prise de notes. Avec contenu les utilisateurs peuvent prendre des captures d'écran de l'écran utilisé pour la prise de notes. la fenêtre flottante de l'application. Les utilisateurs peuvent capturer tout ou partie de l'écran, coller le du contenu dans leur note, et annotent ou mettent en surbrillance le contenu capturé.

Votre application de prise de notes doit fournir une affordance d'UI qui lance une ActivityResultLauncher créé par registerForActivityResult() La ACTION_LAUNCH_CAPTURE_CONTENT_ACTIVITY_FOR_NOTE l'action d'intent est fournie au lanceur d'applications, soit directement, ActivityResultContract

Une activité système capture le contenu, l'enregistre sur l'appareil, puis renvoie le l'URI de contenu de votre application dans l'argument de rappel de registerForActivityResult()

L'exemple suivant utilise une requête StartActivityForResult contrat:

Kotlin

private val startForResult =
registerForActivityResult(  ActivityResultContracts.StartActivityForResult()) {
 result: ActivityResult ->  if (result.resultCode ==
Intent.CAPTURE_CONTENT_FOR_NOTE_SUCCESS) {  val uri = result.data?.data  // Use
the URI to paste the captured content into the note.  }  } override fun
onCreate(savedInstanceState: Bundle?) {  super.onCreate(savedInstanceState)
setContent {  NotesTheme {  Surface(color =
MaterialTheme.colorScheme.background) {  CaptureButton(  onClick = {
Log.i("ContentCapture", "Launching intent...")
startForResult.launch(Intent(ACTION_LAUNCH_CAPTURE_CONTENT_ACTIVITY_FOR_NOTE))
})  }  }  } } @Composable fun CaptureButton(onClick: () -> Unit) {
Button(onClick = onClick)
 {Text("Capture Content")} }

Java

private final ActivityResultLauncher<Intent> startForResult = registerForActivityResult(
    new ActivityResultContracts.StartActivityForResult(),
    result -> {
        if (result.getResultCode() == Intent.CAPTURE_CONTENT_FOR_NOTE_SUCCESS) {
            Uri uri = result.getData() != null ? result.getData().getData() : null;
            // Use the URI to paste the captured content into the note.
        }
    });

@Override
protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_main);

    Button captureButton = findViewById(R.id.capture_button);

    captureButton.setOnClickListener(
        view -> {
            Log.i("ContentCapture", "Launching intent...");
            startForResult.launch(new Intent(ACTION_LAUNCH_CAPTURE_CONTENT_ACTIVITY_FOR_NOTE));
        });
}

Votre application doit gérer tous les codes de résultat :

Une fois la capture du contenu effectuée, collez l'image capturée dans la note. Exemple:

Kotlin

registerForActivityResult(ActivityResultContracts.StartActivityForResult()) {
 result: ActivityResult ->  if (result.resultCode ==
Intent.CAPTURE_CONTENT_FOR_NOTE_SUCCESS) {  val uri = result.data?data  // Use
the URI to paste the captured content into the note.  } }

Java

registerForActivityResult(new ActivityResultContracts.StartActivityForResult(),
    result -> {
        if (result.getResultCode() == Intent.CAPTURE_CONTENT_FOR_NOTE_SUCCESS) {
            Uri uri = result.getData() != null ? result.getData().getData() : null;
            // Use the URI to paste the captured content into the note.
        }
    });

La fonctionnalité de capture de contenu ne doit être exposée via une affordance d'UI que lorsque votre application de prise de notes s'exécute dans une fenêtre flottante, et non lorsque en plein écran, lancé à partir de l'écran de verrouillage de l'appareil. (Les utilisateurs peuvent prendre Captures d'écran de l'application de prise de notes elle-même avec la capture d'écran de l'appareil .

Pour déterminer si votre application se trouve dans une fenêtre flottante (ou info-bulle), appelez la méthode méthodes suivantes:

isLaunchedFromBubble() pour vérifier que votre application de prise de notes n'a pas été lancée en plein écran depuis l'écran de verrouillage de l'appareil
isRoleHeld(RoleManager.ROLE_NOTES) pour vérifier que votre application est l'application de prise de notes par défaut (votre application peut s'exécuter dans une conversation ou un autre type de bulle si l'application ne contient pas rôle "Notes")

Ressources supplémentaires

Obtenir un résultat depuis une activité