Notizen-App erstellen

Notizen sind eine Kernfunktion von Android, die die Produktivität der Nutzer auf Geräten mit großen Bildschirmen verbessert. Mit Notizen-Apps können Nutzer in einem unverankerten Fenster oder im Vollbildmodus schreiben und skizzieren, Bildschirminhalte erfassen und mit Anmerkungen versehen sowie Notizen für spätere Überprüfungen und Überarbeitungen speichern.

Nutzer können über den Sperrbildschirm oder während der Ausführung anderer Apps auf ihre Notizen-Apps zugreifen.

Notizen lassen sich ganz einfach mit Eingabestiften erstellen.

Notizenrolle

Die Rolle RoleManager.ROLE_NOTES identifiziert Apps für Notizen und gewährt ihnen die Berechtigung LAUNCH_CAPTURE_CONTENT_ACTIVITY_FOR_NOTE.

So erhalten Sie die Rolle „Notizen“ für Ihre App:

1. Rufen Sie isRoleAvailable() auf, um den Status der Rolle zu prüfen.
2. Wenn die Notizenrolle verfügbar ist, rufen Sie createRequestRoleIntent() auf, um einen notizenspezifischen Intent zu erhalten.
3. Rufen Sie startActivityForResult() mit dem Notizen-Intent auf, um den Nutzer aufzufordern, Ihrer Anwendung die Notizenrolle zuzuweisen.

Die Rolle „Notizen“ kann nur eine App haben.

Die App wird als Reaktion auf eine implizite ACTION_CREATE_NOTE-Intent-Aktion geöffnet. Wenn sie über den Sperrbildschirm des Geräts aufgerufen wird, öffnet sich die App im Vollbildmodus. Wird sie aufgerufen, während der Bildschirm entsperrt ist, wird sie in einem unverankerten Fenster geöffnet.

Hinweis: In den Systemeinstellungen können Nutzer festlegen, dass keine Standard-App für Notizen verwendet werden soll. In diesem Fall reagiert keine App auf die ACTION_CREATE_NOTE-Intent-Aktion.

App-Manifest

Um sich für die Rolle „Notizen“ zu qualifizieren, muss Ihre App die folgende Deklaration im App-Manifest enthalten:

<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>

Mit der Deklaration können Nutzer der App die Rolle „Notizen“ zuweisen, was sie zur Standardanwendung für Notizen macht:

• Mit ACTION_CREATE_NOTE wird die Intent-Aktion festgelegt, auf die deine App reagiert.

• Mit showWhenLocked kannst du über den Sperrbildschirm des Geräts auf deine App zugreifen

• Mit turnScreenOn kann deine App den Gerätebildschirm einschalten, wenn sie ausgeführt wird

App-Funktionen

Eine differenzierte Notizen-App auf einem großen Bildschirm bietet eine breite Palette von Notizen-Funktionen.

Eingabestift-Unterstützung

Wenn Ihre App aufgerufen wird und der EXTRA_USE_STYLUS_MODE-Intent auf true gesetzt ist, sollte die App eine Notiz öffnen, die die Eingabe per Eingabestift (oder Fingertipp) akzeptiert.

Wenn das zusätzliche Intent-Element auf false gesetzt ist, sollte in Ihrer App eine Notiz geöffnet werden, die Tastatureingaben akzeptiert.

Sperrbildschirmzugriff

Ihre App muss eine Vollbildaktivität bieten, die ausgeführt wird, wenn die App über den Sperrbildschirm des Geräts geöffnet wird.

Ihre App sollte nur ältere Notizen anzeigen, wenn der Nutzer (im entsperrten Gerätestatus) zugestimmt hat, ältere Notizen anzuzeigen. Andernfalls sollte Ihre App immer eine neue Notiz erstellen, wenn sie über den Sperrbildschirm geöffnet wird.

Mit KeyguardManager#isKeyguardLocked() können Sie prüfen, ob Ihre App auf dem Sperrbildschirm gestartet wurde. Wenn Sie den Nutzer bitten möchten, das Gerät zu authentifizieren und zu entsperren, rufen Sie KeyguardManager#requestDismissKeyguard() auf:

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.
  }
});

Warnung :Wenn Ihre App über den Sperrbildschirm des Geräts gestartet wird, muss die Privatsphäre der Nutzer geschützt sein.

Schwebende Fenster

Für die kontextbezogene Notizenerstellung muss Ihre Anwendung eine Aktivität bereitstellen, die in einem unverankerten Fenster geöffnet wird, wenn eine andere Anwendung ausgeführt wird.

Ihre App sollte den multi-instance-Modus unterstützen, damit Nutzer mehrere Notizen in mehreren unverankerten Fenstern erstellen können, auch wenn Ihre Notizen-App im Vollbildmodus oder im geteilten Bildschirmmodus gestartet wird.

Inhaltserfassung

Das Erfassen von Inhalten ist eine wichtige Funktion von Notizen-Apps. Mit der Inhaltserfassung können Nutzer Screenshots der Anzeige hinter dem unverankerten Fenster der Notizen-App machen. Nutzer können den gesamten oder einen Teil der Anzeige aufnehmen, den Inhalt in ihre Notiz einfügen und den aufgenommenen Inhalt mit Anmerkungen versehen oder hervorheben.

Die Notizen-App sollte eine UI-Angebot bereitstellen, die ein von registerForActivityResult() erstelltes ActivityResultLauncher startet. Die Intent-Aktion ACTION_LAUNCH_CAPTURE_CONTENT_ACTIVITY_FOR_NOTE wird für den Launcher entweder direkt oder über einen ActivityResultContract bereitgestellt.

Eine Systemaktivität erfasst den Inhalt, speichert ihn auf dem Gerät und gibt den Inhalts-URI im Callback-Argument von registerForActivityResult() an Ihre App zurück.

Im folgenden Beispiel wird ein generischer StartActivityForResult-Vertrag verwendet:

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));
        });
}

Ihre App sollte alle Ergebniscodes verarbeiten können:

• CAPTURE_CONTENT_FOR_NOTE_SUCCESS
• CAPTURE_CONTENT_FOR_NOTE_FAILED
• CAPTURE_CONTENT_FOR_NOTE_USER_CANCELED
• CAPTURE_CONTENT_FOR_NOTE_WINDOW_MODE_UNSUPPORTED
• CAPTURE_CONTENT_FOR_NOTE_BLOCKED_BY_ADMIN

Wenn die Inhaltserfassung erfolgreich ist, fügen Sie das aufgenommene Bild in die Notiz ein. Beispiel:

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.
        }
    });

Die Funktion zur Inhaltserfassung sollte nur dann über eine UI-Option verfügbar gemacht werden, wenn die Notizen-App in einem unverankerten Fenster ausgeführt wird – und nicht im Vollbildmodus, der über den Sperrbildschirm des Geräts gestartet wird. Nutzer können Screenshots der Notiz-App selbst mit Screenshot-Funktionen auf dem Gerät erstellen.

Um zu ermitteln, ob sich Ihre App in einem unverankerten Fenster (oder einer Bubble) befindet, rufen Sie die folgenden Methoden auf:

• isLaunchedFromBubble(), um zu prüfen, ob die Notizen-App auf dem Sperrbildschirm des Geräts im Vollbildmodus gestartet wurde
• isRoleHeld(RoleManager.ROLE_NOTES), um zu prüfen, ob Ihre App die Standard-App zum Erstellen von Notizen ist. Sie kann in einer Unterhaltung oder einer anderen Art von Bubble ausgeführt werden, wenn sie nicht die Rolle „Notizen“ hat.

Hinweis :Ihre App sollte prüfen, ob die Inhaltserfassung gemäß den Richtlinien der Geräteverwaltung zulässig ist. Rufen Sie getScreenCaptureDisabled() mit null als Argument auf.

Weitere Informationen

• Ergebnis aus einer Aktivität abrufen