Stwórz aplikację do robienia notatek

Robienie notatek to podstawowa funkcja Androida, która zwiększa produktywność użytkowników urządzeniach z dużym ekranem. Aplikacje do notatek umożliwiają użytkownikom pisanie i szkicowanie pływającego okna lub pełnoekranowego, przechwytuj zawartość ekranu i dodawaj do nich adnotacje i zapisać notatki do późniejszego przejrzenia i poprawienia.

Użytkownicy mogą uzyskać dostęp do aplikacji do robienia notatek na ekranie blokady lub po uruchomieniu innych aplikacji.

Obsługa rysika w przypadku robienia notatek zwiększa wygodę korzystania z urządzenia.

Rola dotycząca notatek

RoleManager.ROLE_NOTES identyfikuje aplikacje do robienia notatek i przyznaje im LAUNCH_CAPTURE_CONTENT_ACTIVITY_FOR_NOTE uprawnienia.

Aby przypisać rolę notatek do aplikacji, wykonaj te czynności:

  1. Zadzwoń pod numer isRoleAvailable() aby sprawdzić stan roli.
  2. Jeśli rola notatek jest dostępna, wywołaj createRequestRoleIntent() aby uzyskać intencję charakterystyczną dla nut.
  3. Zadzwoń pod numer startActivityForResult() z intencją poproszenia użytkownika o przypisanie roli do notatek .

Rolę do notatek może mieć tylko jedna aplikacja.

Aplikacja otwiera się w odpowiedzi na ukrycie ACTION_CREATE_NOTE działanie intencji. Jeśli aplikacja zostanie wywołana z ekranu blokady urządzenia, zostanie otwarta na pełnym ekranie ekran; jeśli zostanie wywołana przy odblokowanym ekranie, w pływającym oknie.

Plik manifestu aplikacji

Aby kwalifikować się do roli notatek, aplikacja musi zawierać tę deklarację w manifeście aplikacji:

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

Deklaracja umożliwia użytkownikom przypisanie do aplikacji roli notatek, dzięki czemu domyślna aplikacja do robienia notatek:

  • ACTION_CREATE_NOTE ustawia działanie intencji, na które odpowiada aplikacja

  • showWhenLocked udostępnia aplikację na ekranie blokady urządzenia

  • turnScreenOn umożliwia Twoja aplikacja, aby włączała ekran urządzenia po jej uruchomieniu

Funkcje aplikacji

Aplikacja do robienia notatek na dużym ekranie funkcji robienia notatek.

Obsługa rysika

Gdy aplikacja jest wywoływana za pomocą metody EXTRA_USE_STYLUS_MODE została ustawiona dodatkowa intencja na true, aplikacja powinna otworzyć notatkę, która akceptuje rysik (lub dotykowe).

Jeśli dodatkowa intencja ma wartość false, aplikacja powinna otworzyć notatkę, która akceptuje wprowadzanie tekstu z klawiatury.

Dostęp do ekranu blokady

Aplikacja musi udostępniać aktywność na pełnym ekranie, która działa, gdy jest otwarte na ekranie blokady urządzenia.

Aplikacja powinna wyświetlać notatki historyczne tylko wtedy, gdy użytkownik wyraził na to zgodę (w sekcji Odblokowane urządzenie), aby wyświetlić wcześniejsze notatki. W przeciwnym razie po otwarciu ekranu blokady, aplikacja powinna zawsze tworzyć nową notatkę.

Aby sprawdzić, czy aplikacja została uruchomiona na ekranie blokady, KeyguardManager#isKeyguardLocked() Aby poprosić użytkownika o uwierzytelnienie i odblokowanie urządzenia, wywołaj 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.
  }
});

Pływające okna

Aby można było tworzyć kontekstowe notatki, aplikacja musi zawierać działanie, które otwiera się pływającego okna, gdy uruchomiona jest inna aplikacja.

Aplikacja powinna obsługiwać multi-instance w trybie umożliwiającym użytkownikom tworzenie wielu notatek w wielu pływających oknach, po uruchomieniu aplikacji do robienia notatek na pełnym ekranie lub na podzielonym ekranie. i trybu uzyskiwania zgody.

Rejestrowanie treści

Przechwytywanie treści to jedna z najważniejszych funkcji aplikacji do robienia notatek. Z treścią użytkownicy mogą robić zrzuty ekranu wyświetlacza znajdującego się za ekranem pływającego okna aplikacji. Użytkownicy mogą zrobić zrzut całego ekranu lub jego części, wkleić do notatki, a także opatrzyć adnotacjami lub wyróżnić zarejestrowane treści.

Aplikacja do robienia notatek powinna mieć interfejs użytkownika, który uruchamia ActivityResultLauncher autor: registerForActivityResult() ACTION_LAUNCH_CAPTURE_CONTENT_ACTIVITY_FOR_NOTE działanie intencji jest przekazywane do programu uruchamiającego bezpośrednio lub przez ActivityResultContract

Aktywność systemu przechwytuje treść, zapisuje ją na urządzeniu i zwraca identyfikator URI treści do Twojej aplikacji w argumencie wywołania zwrotnego registerForActivityResult()

W poniższym przykładzie wykorzystano ogólne StartActivityForResult umowa:

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

Aplikacja powinna obsługiwać wszystkie kody wyników:

Gdy przechwytywanie treści się powiedzie, wklej przechwycony obraz do notatki. przykład:

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

Funkcja przechwytywania treści powinna być dostępna za pośrednictwem afordancji UI tylko wtedy, aplikacja do robienia notatek działa w pływającym oknie. uruchomionych na pełnym ekranie, uruchamianych z ekranu blokady urządzenia. (Użytkownicy mogą podjąć zrzuty ekranu aplikacji do robienia notatek wraz ze zrzutami ekranu z urządzenia ).

Aby określić, czy aplikacja znajduje się w pływającym oknie (lub dymku), wywołaj funkcję następujące metody:

  • isLaunchedFromBubble() aby sprawdzić, czy aplikacja do robienia notatek nie została uruchomiona na pełnym ekranie ekran blokady urządzenia
  • isRoleHeld(RoleManager.ROLE_NOTES) aby sprawdzić, czy jest domyślną aplikacją do robienia notatek. uruchamiają się w rozmowie lub w innym rodzaju dymka, jeśli aplikacja nie trzyma rolę notatek)
.

Dodatkowe materiały