Crea un'app per scrivere note

L'aggiunta di note è una funzionalità fondamentale di Android che migliora la produttività degli utenti su dispositivi con schermi di grandi dimensioni. Le app per prendere appunti consentono agli utenti di scrivere e disegnare una finestra mobile o a schermo intero, acquisisci e annota i contenuti dello schermo, e salvare note per rivederle in un secondo momento.

Gli utenti possono accedere alle app per creare note dalla schermata di blocco o mentre eseguono altre app.

Il supporto dello stilo per l'aggiunta di note offre un'esperienza utente eccezionale.

Ruolo Note

La RoleManager.ROLE_NOTES identifica le app per prendere appunti e concede loro il LAUNCH_CAPTURE_CONTENT_ACTIVITY_FOR_NOTE autorizzazione.

Per acquisire il ruolo per le note per la tua app:

1. Chiama il numero isRoleAvailable() per controllare lo stato del ruolo.
2. Se il ruolo Note è disponibile, chiama createRequestRoleIntent() per ottenere un intento specifico delle note.
3. Chiama il numero startActivityForResult() con l'intent per le note per richiedere all'utente di concedere il ruolo per le note al tuo dell'app.

Il ruolo Note può essere associato a un'unica app.

L'app si apre in risposta a una richiesta ACTION_CREATE_NOTE azione basata sull'intent. Se la chiamata viene richiamata dalla schermata di blocco del dispositivo, l'app si apre completamente schermo; se richiamato mentre lo schermo è sbloccato, in una finestra mobile.

File manifest dell'app

Per poter usufruire del ruolo Note, la tua app deve includere la seguente dichiarazione nel file manifest dell'app:

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

La dichiarazione consente agli utenti di assegnare il ruolo per le note alla tua app, l'applicazione predefinita per prendere appunti:

• ACTION_CREATE_NOTE Imposta l'azione intent a cui risponde l'app

• showWhenLocked Rende la tua app accessibile dalla schermata di blocco del dispositivo

• turnScreenOn attiva la tua app per attivare lo schermo del dispositivo quando è in esecuzione

Funzionalità dell'app

Completa l'offerta un'app per prendere appunti differenziata su un grande schermo per prendere appunti.

Supporto per stilo

Quando la tua app viene richiamata con EXTRA_USE_STYLUS_MODE per intent impostato su true, l'app dovrebbe aprire una nota che accetta stilo (o tocco con le dita).

Se l'extra per intent è impostato su false, la tua app dovrebbe aprire una nota che accetta l'input da tastiera.

Accesso alla schermata di blocco

La tua app deve fornire un'attività a schermo intero che viene eseguita quando viene aperta dalla schermata di blocco del dispositivo.

L'app deve mostrare solo le note storiche se l'utente ha espresso il consenso (nel stato del dispositivo sbloccato) per visualizzare le note precedenti. Altrimenti, quando viene aperto schermata di blocco, l'app dovrebbe sempre creare una nuova nota.

Puoi controllare se la tua app è stata avviata dalla schermata di blocco con KeyguardManager#isKeyguardLocked() Per chiedere all'utente di autenticare e sbloccare il dispositivo, chiama 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.
  }
});

Finestre mobili

Per prendere appunti contestuali, la tua app deve fornire un'attività che si apre in una quando è in esecuzione un'altra applicazione.

La tua app dovrebbe supportare multi-instance in modo che gli utenti possano creare più note in più finestre mobili, anche Quando l'app per scrivere note viene avviata a schermo intero o in modalità schermo diviso .

Acquisizione dei contenuti

L'acquisizione di contenuti è una funzionalità chiave delle app per creare note. Con contenuti acquisizioni, gli utenti possono acquisire screenshot del display su cui possono prendere appunti finestra mobile dell'app. Gli utenti possono acquisire l'intero display o solo una parte, quindi incollare contenuti nelle note e annotare o evidenziare i contenuti acquisiti.

L'app per prendere appunti deve fornire un'invito UI che avvii un ActivityResultLauncher creato da registerForActivityResult(). La ACTION_LAUNCH_CAPTURE_CONTENT_ACTIVITY_FOR_NOTE viene fornita all'Avvio app direttamente o tramite un ActivityResultContract.

Un'attività di sistema acquisisce i contenuti, li salva sul dispositivo e restituisce l'URI content URI della tua app nell'argomento callback di registerForActivityResult().

L'esempio seguente utilizza un modello StartActivityForResult contratto:

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

L'app deve gestire tutti i codici risultato:

• 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

Al termine dell'acquisizione dei contenuti, incolla l'immagine acquisita nella nota, per esempio:

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

La funzionalità di acquisizione dei contenuti deve essere esposta tramite un'invito UI solo quando l'app per scrivere note è in esecuzione in una finestra mobile, non quando la modalità a schermo intero, avviata dalla schermata di blocco del dispositivo. Gli utenti possono screenshot dell'app per creare note con screenshot del dispositivo funzionalità.)

Per determinare se l'app si trova in una finestra mobile (o in una bolla), richiama la funzione seguenti metodi:

• isLaunchedFromBubble() per verificare che l'app per la creazione di note non sia stata avviata a schermo intero da la schermata di blocco del dispositivo
• isRoleHeld(RoleManager.ROLE_NOTES) per verificare che la tua app sia l'app predefinita per la creazione di note (la tua app può l'esecuzione in una conversazione o in un altro tipo di fumetto se l'app non tiene premuto il ruolo Note)

Risorse aggiuntive

• Ottenere un risultato da un'attività