Controlla l'accesso ai dati

Puoi ottenere informazioni su come la tua app e le sue dipendenze accedono ai dati privati degli utenti eseguendo controlli dell'accesso ai dati. Questa procedura, disponibile sui dispositivi con Android 11 (livello API 30) o versioni successive, ti consente di identificare meglio gli accessi ai dati potenzialmente inaspettati. La tua app può registrare un'istanza di AppOpsManager.OnOpNotedCallback, che può eseguire azioni ogni volta che si verifica uno dei seguenti eventi:

• Il codice della tua app accede a dati privati. Per aiutarti a determinare quale parte logica della tua app ha invocato l'evento, puoi controllare l'accesso ai dati in base al tag di attribuzione.
• Il codice in una libreria o in un SDK dipendente accede a dati privati.

Il controllo dell'accesso ai dati viene invocato nel thread in cui avviene la richiesta di dati. Ciò significa che se un SDK o una libreria di terze parti nella tua app chiama un'API che accede a dati privati, il controllo dell'accesso ai dati consente a OnOpNotedCallback di esaminare le informazioni sulla chiamata. In genere, questo oggetto di callback può stabilire se la chiamata proviene dalla tua app o dall'SDK esaminando lo stato corrente dell'app, ad esempio la traccia dello stack del thread corrente.

Registrare l'accesso ai dati

Per eseguire il controllo dell'accesso ai dati utilizzando un'istanza di AppOpsManager.OnOpNotedCallback, implementa la logica di callback nel componente dove intendi controllare l'accesso ai dati, ad esempio all'interno del metodo onCreate() di un'attività o del metodo onCreate() di un'applicazione.

Il seguente snippet di codice definisce un AppOpsManager.OnOpNotedCallback per controllare l'accesso ai dati all'interno di un'unica attività:

override fun onCreate(savedInstanceState: Bundle?) {
    val appOpsCallback = object : AppOpsManager.OnOpNotedCallback() {
        private fun logPrivateDataAccess(opCode: String, trace: String) {
            Log.i(MY_APP_TAG, "Private data accessed. " +
                    "Operation: $opCode\nStack Trace:\n$trace")
        }

        override fun onNoted(syncNotedAppOp: SyncNotedAppOp) {
            logPrivateDataAccess(
                    syncNotedAppOp.op, Throwable().stackTrace.toString())
        }

        override fun onSelfNoted(syncNotedAppOp: SyncNotedAppOp) {
            logPrivateDataAccess(
                    syncNotedAppOp.op, Throwable().stackTrace.toString())
        }

        override fun onAsyncNoted(asyncNotedAppOp: AsyncNotedAppOp) {
            logPrivateDataAccess(asyncNotedAppOp.op, asyncNotedAppOp.message)
        }
    }

    val appOpsManager =
            getSystemService(AppOpsManager::class.java) as AppOpsManager
    appOpsManager.setOnOpNotedCallback(mainExecutor, appOpsCallback)
}

@Override
public void onCreate(@Nullable Bundle savedInstanceState,
        @Nullable PersistableBundle persistentState) {
    AppOpsManager.OnOpNotedCallback appOpsCallback =
            new AppOpsManager.OnOpNotedCallback() {
        private void logPrivateDataAccess(String opCode, String trace) {
            Log.i(MY_APP_TAG, "Private data accessed. " +
                    "Operation: $opCode\nStack Trace:\n$trace");
        }

        @Override
        public void onNoted(@NonNull SyncNotedAppOp syncNotedAppOp) {
            logPrivateDataAccess(syncNotedAppOp.getOp(),
                    Arrays.toString(new Throwable().getStackTrace()));
        }

        @Override
        public void onSelfNoted(@NonNull SyncNotedAppOp syncNotedAppOp) {
            logPrivateDataAccess(syncNotedAppOp.getOp(),
                    Arrays.toString(new Throwable().getStackTrace()));
        }

        @Override
        public void onAsyncNoted(@NonNull AsyncNotedAppOp asyncNotedAppOp) {
            logPrivateDataAccess(asyncNotedAppOp.getOp(),
                    asyncNotedAppOp.getMessage());
        }
    };

    AppOpsManager appOpsManager = getSystemService(AppOpsManager.class);
    if (appOpsManager != null) {
        appOpsManager.setOnOpNotedCallback(getMainExecutor(), appOpsCallback);
    }
}

I metodi onAsyncNoted() e onSelfNoted() vengono chiamati in situazioni specifiche:

• onAsyncNoted() viene chiamato se l'accesso ai dati non avviene durante la chiamata all'API della tua app. L'esempio più comune è quando la tua app registra un ascoltatore e l'accesso ai dati avviene ogni volta che viene invocato il callback dell'ascoltatore.

  L'argomento AsyncNotedOp passato a onAsyncNoted() contiene un metodo chiamato getMessage(). Questo metodo fornisce maggiori informazioni sull'accesso ai dati. Nel caso dei callback della posizione, il messaggio contiene l'hash dell'identità di sistema dell'ascoltatore.

• onSelfNoted() viene chiamato nel caso molto raro in cui un'app trasmette il proprio UID a noteOp().

Controllare l'accesso ai dati in base al tag di attribuzione

La tua app potrebbe avere diversi casi d'uso principali, ad esempio consentire agli utenti di scattare foto e condividerle con i loro contatti. Se sviluppi un'app multiuso, puoi applicare un tag di attribuzione a ogni parte dell'app quando ne controlli l'accesso ai dati. Il contesto attributionTag viene restituito gli oggetti passati alle chiamate a onNoted(). In questo modo puoi risalire più facilmente all'accesso ai dati nelle parti logiche del codice.

Per definire i tag di attribuzione nella tua app, completa i passaggi descritti nelle seguenti sezioni.

Dichiarare i tag di attribuzione nel manifest

Se la tua app ha come target Android 12 (livello API 31) o versioni successive, devi dichiarare i tag di attribuzione nel file manifest dell'app utilizzando il formato mostrato nel seguente snippet di codice. Se provi a utilizzare un tag di attribuzione che non dichiari nel file manifest della tua app, il sistema crea un tag null e registra un messaggio in Logcat.

<manifest ...>
    <!-- The value of "android:tag" must be a literal string, and the
         value of "android:label" must be a resource. The value of
         "android:label" is user-readable. -->
    <attribution android:tag="sharePhotos"
                 android:label="@string/share_photos_attribution_label" />
    ...
</manifest>

Creare tag di attribuzione

Nel metodo onCreate() dell'attività in cui accedi ai dati, ad esempio l'attività in cui richiedi la posizione o accedi all'elenco di contatti dell'utente, chiama createAttributionContext(), passando il tag di attribuzione che vuoi associare a una parte della sua app.

Il seguente snippet di codice mostra come creare un tag di attribuzione per la funzionalità di condivisione di foto e posizione di un'app:

class SharePhotoLocationActivity : AppCompatActivity() {
    lateinit var attributionContext: Context

    override fun onCreate(savedInstanceState: Bundle?) {
        attributionContext = createAttributionContext("sharePhotos")
    }

    fun getLocation() {
        val locationManager = attributionContext.getSystemService(
                LocationManager::class.java) as LocationManager
        // Use "locationManager" to access device location information.
    }
}

public class SharePhotoLocationActivity extends AppCompatActivity {
    private Context attributionContext;

    @Override
    public void onCreate(@Nullable Bundle savedInstanceState,
            @Nullable PersistableBundle persistentState) {
        attributionContext = createAttributionContext("sharePhotos");
    }

    public void getLocation() {
        LocationManager locationManager =
                attributionContext.getSystemService(LocationManager.class);
        if (locationManager != null) {
            // Use "locationManager" to access device location information.
        }
    }
}

Includi i tag di attribuzione nei log di accesso

Aggiorna il callback AppOpsManager.OnOpNotedCallback in modo che i log della tua app includano i nomi dei tag di attribuzione che hai definito.

Il seguente snippet di codice mostra la logica aggiornata che registra i tag di attribuzione:

val appOpsCallback = object : AppOpsManager.OnOpNotedCallback() {
    private fun logPrivateDataAccess(
            opCode: String, attributionTag: String, trace: String) {
        Log.i(MY_APP_TAG, "Private data accessed. " +
                    "Operation: $opCode\n " +
                    "Attribution Tag:$attributionTag\nStack Trace:\n$trace")
    }

    override fun onNoted(syncNotedAppOp: SyncNotedAppOp) {
        logPrivateDataAccess(syncNotedAppOp.op,
                syncNotedAppOp.attributionTag,
                Throwable().stackTrace.toString())
    }

    override fun onSelfNoted(syncNotedAppOp: SyncNotedAppOp) {
        logPrivateDataAccess(syncNotedAppOp.op,
                syncNotedAppOp.attributionTag,
                Throwable().stackTrace.toString())
    }

    override fun onAsyncNoted(asyncNotedAppOp: AsyncNotedAppOp) {
        logPrivateDataAccess(asyncNotedAppOp.op,
                asyncNotedAppOp.attributionTag,
                asyncNotedAppOp.message)
    }
}

@Override
public void onCreate(@Nullable Bundle savedInstanceState,
        @Nullable PersistableBundle persistentState) {
    AppOpsManager.OnOpNotedCallback appOpsCallback =
            new AppOpsManager.OnOpNotedCallback() {
        private void logPrivateDataAccess(String opCode,
                String attributionTag, String trace) {
            Log.i("MY_APP_TAG", "Private data accessed. " +
                    "Operation: $opCode\n " +
                    "Attribution Tag:$attributionTag\nStack Trace:\n$trace");
        }

        @Override
        public void onNoted(@NonNull SyncNotedAppOp syncNotedAppOp) {
            logPrivateDataAccess(syncNotedAppOp.getOp(),
                    syncNotedAppOp.getAttributionTag(),
                    Arrays.toString(new Throwable().getStackTrace()));
        }

        @Override
        public void onSelfNoted(@NonNull SyncNotedAppOp syncNotedAppOp) {
            logPrivateDataAccess(syncNotedAppOp.getOp(),
                    syncNotedAppOp.getAttributionTag(),
                    Arrays.toString(new Throwable().getStackTrace()));
        }

        @Override
        public void onAsyncNoted(@NonNull AsyncNotedAppOp asyncNotedAppOp) {
            logPrivateDataAccess(asyncNotedAppOp.getOp(),
                    asyncNotedAppOp.getAttributionTag(),
                    asyncNotedAppOp.getMessage());
        }
    };

    AppOpsManager appOpsManager = getSystemService(AppOpsManager.class);
    if (appOpsManager != null) {
        appOpsManager.setNotedAppOpsCollector(appOpsCollector);
    }
}