Notizen-App erstellen

Notizen sind eine Kernfunktion von Android, die die Produktivität der Nutzer auf Geräte mit großem Bildschirm. Mit Notizen-Apps können Nutzer in einem unverankerten Fenster oder auf dem Vollbildschirm sichtbar sein, um Bildschirminhalte zu erfassen und Notizen zur späteren Überprüfung und Überarbeitung speichern.

Nutzer können über den Sperrbildschirm oder beim Ausführen anderer Apps.

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

Notizenrolle

Die RoleManager.ROLE_NOTES identifiziert Notizen-Apps und gewährt ihnen die Berechtigung, LAUNCH_CAPTURE_CONTENT_ACTIVITY_FOR_NOTE Berechtigung.

So erwerben Sie die Notizenrolle für Ihre App:

1. isRoleAvailable() anrufen um den Status der Rolle zu überprüfen.
2. Wenn die Rolle für Notizen verfügbar ist, rufen Sie createRequestRoleIntent() auf. um einen notizenspezifischen Intent zu erhalten.
3. startActivityForResult() anrufen mit dem Notizen-Intent, um den Nutzer aufzufordern, Ihrem Konto die Rolle für Notizen zu gewähren.

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

Die Anwendung wird als Reaktion auf eine implizite ACTION_CREATE_NOTE Intent-Aktion. Bei Aufruf über den Sperrbildschirm des Geräts wird die App vollständig geöffnet Bildschirm; wenn sie aufgerufen werden, während der Bildschirm entsperrt ist, in einem unverankerten Fenster.

App-Manifest

Damit du die Rolle für Notizen nutzen kannst, muss deine App die folgende Erklärung enthalten im App-Manifest:

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

Durch die Deklaration können Nutzer Ihrer App die Rolle „Notizen“ zuweisen. Standard-Notizen-App:

• ACTION_CREATE_NOTE Legt die Intent-Aktion fest, auf die Ihre App reagiert

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

• turnScreenOn aktiviert Ihre App, um den Gerätebildschirm zu aktivieren, wenn die App ausgeführt wird

App-Funktionen

Auf dem großen Bildschirm kannst du Notizen machen – perfekt aufeinander abgestimmt Funktionen für die Notizenerstellung.

Eingabestift-Unterstützung

Wenn Ihre App mit dem EXTRA_USE_STYLUS_MODE Intent-Extra auf true gesetzt ist, sollte die App eine Notiz öffnen, in der ein Eingabestift (oder Touchbedienung).

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

Zugriff auf Sperrbildschirm

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

In Ihrer App sollten nur dann bisherige Notizen angezeigt werden, wenn der Nutzer in den Gerät entsperrt, um frühere Notizen anzuzeigen. Andernfalls öffnen Sie sie über die Sperrbildschirm erstellt wird, sollte Ihre App immer eine neue Notiz erstellen.

Mit der Schaltfläche KeyguardManager#isKeyguardLocked() Um den Nutzer zu bitten, das Gerät zu authentifizieren und zu entsperren, rufen Sie KeyguardManager#requestDismissKeyguard():

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 App eine Aktivität bereitstellen, die in einer ein unverankertes Fenster, wenn eine andere Anwendung ausgeführt wird.

Deine App sollte Folgendes unterstützen: multi-instance Modus, sodass Nutzende mehrere Notizen in mehreren unverankerten Fenstern erstellen können, selbst Wenn Ihre Notizen-App im Vollbildmodus oder im Splitscreen-Modus gestartet wird .

Inhalte erfassen

Die Inhaltsaufnahme ist eine wichtige Funktion von Notizen-Apps. Mit Inhalten können Nutzer Screenshots vom Display hinter den Notizen machen. das unverankerte Fenster der App. Nutzer können den gesamten Bildschirm oder Teile davon aufnehmen, den Inhalte in ihre Notiz einfügen und den erfassten Inhalt mit Anmerkungen versehen oder hervorheben.

Ihre Notizen-App sollte eine UI-Funktion bieten, die eine ActivityResultLauncher erstellt von registerForActivityResult() Die ACTION_LAUNCH_CAPTURE_CONTENT_ACTIVITY_FOR_NOTE Intent-Aktion wird dem Launcher entweder direkt oder über eine ActivityResultContract

Eine Systemaktivität erfasst die Inhalte, speichert sie auf dem Gerät und gibt den Inhalts-URI zu deiner App im Callback-Argument von registerForActivityResult()

Im folgenden Beispiel wird eine allgemeine StartActivityForResult Vertrag:

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 eine UI-Option bereitgestellt werden, wenn Ihre Notiz-App in einem unverankerten Fenster ausgeführt wird, nicht, wenn wird im Vollbildmodus ausgeführt und über den Sperrbildschirm des Geräts gestartet. (Nutzer können Screenshots der Notizen-App selbst mit Geräte-Screenshot Funktionen.)

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

• isLaunchedFromBubble() können Sie überprüfen, ob Ihre Notizen-App auf dem Sperrbildschirm des Geräts
• isRoleHeld(RoleManager.ROLE_NOTES) um zu prüfen, ob deine App die Standard-App für Notizen ist. Deine App kann die in einer Unterhaltung oder einer anderen Art von Bubble angezeigt wird, Notizenrolle)

Weitere Informationen

• Ergebnis aus einer Aktivität abrufen