Notizen-App erstellen

Notizen sind eine Hauptfunktion 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 auf dem Sperrbildschirm oder während der Ausführung anderer Apps auf ihre Notizen-Apps zugreifen.

Notizen lassen sich ganz einfach mit Eingabestiften erstellen.

Notizenrolle

Mit der Rolle RoleManager.ROLE_NOTES werden Notizen-Apps identifiziert und die Berechtigung LAUNCH_CAPTURE_CONTENT_ACTIVITY_FOR_NOTE gewährt.

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 Rolle „Notizen“ 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 App die Notizenrolle zuzuweisen.

Die Rolle „Notizen“ kann nur eine App haben.

Die App wird als Reaktion auf eine implizite Intent-Aktion vom Typ ACTION_CREATE_NOTE 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.

App-Manifest

Um die Rolle „Notizen“ nutzen zu können, 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 Ihrer App die Rolle „Notizen“ zuweisen, was sie zur Standardanwendung für Notizen macht:

• ACTION_CREATE_NOTE legt die Intent-Aktion fest, auf die deine App reagiert

• showWhenLocked macht deine App über den Sperrbildschirm des Geräts zugänglich

• turnScreenOn ermöglicht deiner App, den Gerätebildschirm zu aktivieren, wenn die App ausgeführt wird

App-Funktionen

Die App bietet eine breite Palette an Notizen-Funktionen auf dem großen Bildschirm.

Eingabestift-Unterstützung

Wenn Ihre App aufgerufen wird und der Intent EXTRA_USE_STYLUS_MODE auf true gesetzt ist, sollte eine Notiz geöffnet werden, 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 unterstützt.

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 vom Sperrbildschirm aus 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:

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

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

Schwebende Fenster

Für die kontextbezogene Notizenerstellung muss Ihre App 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, selbst 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 Funktion zur Inhaltserfassung können Nutzer Screenshots des Displays hinter dem unverankerten Fenster der Notizen-App aufnehmen. Nutzer können den gesamten Bildschirm oder einen Teil davon aufnehmen, den Inhalt in ihre Notiz einfügen und den aufgenommenen Inhalt mit Anmerkungen versehen oder hervorheben.

Ihre Notizen-App sollte eine Benutzeroberfläche bieten, über die ein von registerForActivityResult() erstellter ActivityResultLauncher gestartet wird. Die Intent-Aktion ACTION_LAUNCH_CAPTURE_CONTENT_ACTIVITY_FOR_NOTE wird dem Launcher entweder direkt oder über eine ActivityResultContract zur Verfügung gestellt.

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

Im folgenden Beispiel wird ein generischer StartActivityForResult-Vertrag verwendet:

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

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:

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

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 zum Erfassen von Inhalten sollte nur dann über die Benutzeroberfläche sichtbar sein, wenn Ihre Notizen-App in einem unverankerten Fenster ausgeführt wird – nicht im Vollbildmodus, wenn sie über den Sperrbildschirm des Geräts gestartet wird. Mit den Screenshot-Funktionen auf dem Gerät können Nutzer Screenshots der Notiz-App selbst 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. Ihre App kann in einer Unterhaltung oder einer anderen Art von Bubble ausgeführt werden, wenn sie nicht über die Notizenrolle verfügt.

Weitere Informationen

• Unterstützung erweiterter Eingabestiftfunktionen
• Ergebnis aus einer Aktivität abrufen