Notizen-App erstellen

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

Nutzer können über den Sperrbildschirm oder beim Ausführen anderer Apps auf Notizen-Apps zugreifen.

Die Unterstützung des Eingabestifts zum Erstellen von Notizen ist besonders nutzerfreundlich.

Notizenrolle

Die Rolle RoleManager.ROLE_NOTES identifiziert Notizenanwendungen und gewährt ihnen die Berechtigung LAUNCH_CAPTURE_CONTENT_ACTIVITY_FOR_NOTE.

So erwerben Sie die Notizenrolle 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 abzurufen.
3. Rufen Sie startActivityForResult() mit dem Notizen-Intent auf, um den Nutzer aufzufordern, Ihrer Anwendung die Rolle für Notizen zu gewähren.

Nur eine App kann die Rolle für Notizen haben.

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

App-Manifest

Um sich für die Notizenrolle zu qualifizieren, muss deine 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 für Notizen zuweisen und sie dadurch zur Standardanwendung für Notizen machen:

• Mit ACTION_CREATE_NOTE wird die Intent-Aktion festgelegt, auf die Ihre 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 große Bildschirm-App für Notizen mit unterschiedlichen Funktionen bietet umfassende Funktionen.

Eingabestift-Unterstützung

Wenn Ihre App mit dem zusätzlichen Intent EXTRA_USE_STYLUS_MODE aufgerufen wird, der auf true gesetzt ist, sollte in der App eine Notiz geöffnet werden, die Eingaben per Eingabestift (oder Fingerabdruck) akzeptiert.

Wenn das Intent-Extra auf false gesetzt ist, sollte in der App eine Notiz geöffnet werden, die Tastatureingaben akzeptiert.

Zugriff auf Sperrbildschirm

Deine 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 dann historische Notizen anzeigen, wenn der Nutzer der Anzeige früherer Notizen (im entsperrten Gerätestatus) zugestimmt hat. 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 über den Sperrbildschirm gestartet wurde. Rufen Sie KeyguardManager#requestDismissKeyguard() auf, um den Nutzer aufzufordern, das Gerät zu authentifizieren und zu entsperren:

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 kontextbezogene Notizen muss Ihre Anwendung eine Aktivität bereitstellen, die in einem unverankerten Fenster geöffnet wird, wenn eine andere Anwendung ausgeführt wird.

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

Inhalte erfassen

Die Inhaltsaufnahme ist eine wichtige Funktion von Notizen-Apps. Mit der Inhaltserfassung können Nutzer Screenshots des Bildschirms hinter dem unverankerten Fenster der App für Notizen machen. Nutzer können die Anzeige vollständig oder teilweise erfassen, den Inhalt in ihre Notiz einfügen und den erfassten Inhalt mit Anmerkungen versehen oder hervorheben.

Ihre Notizen-App sollte eine UI-Option bieten, die ein von registerForActivityResult() erstelltes ActivityResultLauncher startet. Die Intent-Aktion ACTION_LAUNCH_CAPTURE_CONTENT_ACTIVITY_FOR_NOTE wird dem Launcher entweder direkt oder über eine ActivityResultContract bereitgestellt.

Eine Systemaktivität erfasst den Inhalt, speichert ihn auf dem Gerät und gibt den Inhalts-URI an Ihre App im Callback-Argument von registerForActivityResult() 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 war, 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 Inhaltserfassungsfunktion sollte nur dann über die Benutzeroberfläche zur Verfügung gestellt werden, wenn Ihre Notizen-App in einem unverankerten Fenster ausgeführt wird, nicht, wenn sie im Vollbildmodus ausgeführt wird und über den Sperrbildschirm des Geräts gestartet wird. (Nutzer können Screenshots der Notiz-App selbst mit der Screenshot-Funktion auf dem Gerät erstellen.)

Mit den folgenden Methoden können Sie feststellen, ob sich Ihre Anwendung in einem unverankerten Fenster (oder Infofeld) befindet:

• 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 deine App die Standard-App für Notizen ist. Deine App kann in einer Unterhaltung oder einer anderen Art von Bubble ausgeführt werden, wenn sie nicht die Notizenrolle hat.

Zusätzliche Ressourcen

• Ergebnis aus einer Aktivität abrufen