Cómo crear una app para tomar notas

Tomar notas es una función principal de Android que mejora la productividad del usuario en dispositivos con pantallas grandes. Las apps para tomar notas les permiten a los usuarios escribir y dibujar en una ventana flotante o en pantalla completa, capturar y anotar el contenido de la pantalla, y guarde notas para revisarlas y revisarlas más tarde.

Los usuarios pueden acceder a las apps para tomar notas desde la pantalla de bloqueo o mientras ejecutan otras apps de Google Chat.

La compatibilidad con la pluma stylus para tomar notas ofrece una experiencia del usuario excepcional.

Rol de notas

El RoleManager.ROLE_NOTES del rol identifica las apps para tomar notas y les otorga LAUNCH_CAPTURE_CONTENT_ACTIVITY_FOR_NOTE permiso.

Para adquirir el rol de notas para tu app, haz lo siguiente:

1. Llama a isRoleAvailable() para verificar el estado del rol.
2. Si el rol de notas está disponible, llama a createRequestRoleIntent(). para obtener un intent específico de notas.
3. Llama a startActivityForResult() con el intent de notas para solicitarle al usuario que otorgue el rol de notas a tu .

Solo una app puede tener el rol de notas.

La app se abre en respuesta a una respuesta ACTION_CREATE_NOTE acción de intent. Si se invoca desde la pantalla de bloqueo del dispositivo, la app se abre pantalla; si se invoca mientras la pantalla está desbloqueada, en una ventana flotante.

Nota: En la configuración del sistema, los usuarios pueden inhabilitar la opción app para tomar notas, en cuyo caso ninguna app responde al ACTION_CREATE_NOTE acción de intent.

Manifiesto de la app

Para cumplir con los requisitos para el rol de notas, tu app debe incluir la siguiente declaración En el manifiesto de la 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 declaración permite que los usuarios asignen el rol de notas a tu app, lo que hace que la aplicación predeterminada para tomar notas:

• ACTION_CREATE_NOTE Configura la acción de intent a la que responde tu app

• showWhenLocked Permite que se pueda acceder a tu app desde la pantalla de bloqueo del dispositivo.

• turnScreenOn habilita tu app para encender la pantalla del dispositivo cuando se ejecute

Características de la app

Una app diferenciada para tomar notas en una pantalla grande brinda un complemento completo de capacidades para tomar notas.

Compatibilidad con pluma stylus

Cuando se invoca tu app con el EXTRA_USE_STYLUS_MODE intent adicional establecido en true, la app debe abrir una nota que acepte la pluma stylus (o entrada táctil).

Si el intent adicional se establece en false, tu app debe abrir una nota que acepte la entrada del teclado.

Acceso a la pantalla de bloqueo

Tu app debe proporcionar una actividad de pantalla completa que se ejecute cuando se ejecute abierto desde la pantalla de bloqueo del dispositivo.

Tu app solo debe mostrar notas históricas si el usuario dio su consentimiento (en la estado de dispositivo desbloqueado) para mostrar notas anteriores. De lo contrario, cuando se abra desde pantalla de bloqueo, la aplicación siempre debería crear una nueva nota.

Puedes comprobar si tu app se inició desde la pantalla de bloqueo con KeyguardManager#isKeyguardLocked() Para pedirle al usuario que se autentique y desbloquee el dispositivo, llama 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.
  }
});

Advertencia: Cuando se inicia desde la pantalla de bloqueo del dispositivo, la app debe garantizar y su privacidad.

Ventanas flotantes

Para tomar notas contextuales, tu app debe proporcionar una actividad que se abra en un ventana flotante cuando se ejecuta otra aplicación.

Tu app debería ser compatible multi-instance para que los usuarios puedan crear varias notas en múltiples ventanas flotantes, incluso Cuando tu app para tomar notas se inicia en pantalla completa o en pantalla dividida .

Captura de contenido

La captura de contenido es una función clave de las apps para tomar notas. Con contenido captura, los usuarios pueden tomar capturas de pantalla de la pantalla detrás de la toma de notas la ventana flotante de la app. Los usuarios pueden capturar toda la pantalla o parte de ella, pegar contenido en su nota y realizar anotaciones o destacar el contenido capturado.

Tu app para tomar notas debe proporcionar una indicación visual de la IU que inicie un ActivityResultLauncher creado por registerForActivityResult() El ACTION_LAUNCH_CAPTURE_CONTENT_ACTIVITY_FOR_NOTE se proporciona al selector directamente o a través de un ActivityResultContract

Una actividad del sistema captura el contenido, lo guarda en el dispositivo y devuelve la de contenido de tu app en el argumento de devolución de llamada de registerForActivityResult()

En el siguiente ejemplo, se usa un modelo StartActivityForResult contrato:

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

Tu app debe controlar todos los códigos de resultado:

• 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

Cuando la captura de contenido se realice correctamente, pega la imagen capturada en la nota por ejemplo:

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

La función de captura de contenido debe exponerse a través de una indicación visual de la IU solo cuando que tu app para tomar notas se ejecute en una ventana flotante, no cuando ejecutándose en pantalla completa, iniciada desde la pantalla de bloqueo del dispositivo. (Los usuarios pueden tomar Capturas de pantalla de la propia app para tomar notas con una captura de pantalla del dispositivo capacidades).

Para determinar si tu app está en una ventana flotante (o un cuadro), llama al con los siguientes métodos:

• isLaunchedFromBubble() para comprobar que tu app para tomar notas no se haya iniciado en pantalla completa desde la pantalla de bloqueo del dispositivo
• isRoleHeld(RoleManager.ROLE_NOTES) para verificar que tu app sea la predeterminada para tomar notas (se puede se ejecutará en una conversación u otro tipo de cuadro si la app no contiene rol de notas)

Nota: La app debe verificar si el dispositivo permite la captura de contenido. políticas administrativas. Llamada getScreenCaptureDisabled() con null como argumento.

Recursos adicionales

• Cómo obtener el resultado de una actividad