A partire dal 2026, per allinearci al nostro modello di sviluppo stabile del trunk e garantire la stabilità della piattaforma per l'ecosistema, pubblicheremo il codice sorgente su AOSP nel secondo e nel quarto trimestre. Per la creazione e il contributo ad AOSP, consigliamo di utilizzare android-latest-release anziché aosp-main. Il ramo del manifest android-latest-release farà sempre riferimento alla release più recente inviata ad AOSP. Per saperne di più, vedi Modifiche ad AOSP.

ChunkHandler

public abstract class ChunkHandler
extends JdwpInterceptor

java.lang.Object
↳	com.android.tradefed.device.server.jdwp.JdwpInterceptor
	↳	com.android.tradefed.device.server.jdwp.chunkhandler.ChunkHandler

Sottoclassi dirette note

DebugViewDumpHandler, HandleAppName, HandleExit, HandleHeap, HandleHello, HandleNativeHeap, HandleProfiling, HandleTest, HandleThread, HandleViewDebug, HandleWait

DebugViewDumpHandler
HandleAppName	Gestisci il blocco "app name" (APNM).
HandleExit	Invia una richiesta di uscita.
HandleHeap	Gestire gli aggiornamenti dello stato dell'heap.
HandleHello	Gestisci il blocco "hello" (HELO) e il rilevamento delle funzionalità.
HandleNativeHeap	Gestire gli aggiornamenti dello stato dei thread.
HandleProfiling	Gestire gli aggiornamenti dello stato dell'heap.
HandleTest	Gestire gli aggiornamenti dello stato dei thread.
HandleThread	Gestire gli aggiornamenti dello stato dei thread.
HandleViewDebug
HandleWait	Gestisci il blocco "wait" (WAIT).

Esegui la sottoclasse con una classe che gestisce uno o più tipi di chunk.

Riepilogo

Costanti
`int`	`CHUNK_HEADER_LEN`
`int`	`DDMS_CMD`
`int`	`DDMS_CMD_SET`

Campi
`public static final int`	`CHUNK_FAIL`
`public static final ByteOrder`	`CHUNK_ORDER`

Costruttori pubblici
`ChunkHandler()`

Metodi pubblici
`static ByteBuffer`	`allocBuffer(int maxChunkLen)` Alloca un ByteBuffer con spazio sufficiente per contenere l'intestazione del pacchetto JDWP e un'intestazione del blocco oltre alle esigenze del blocco da creare.
`abstract void`	`clientDisconnected(ClientImpl client)` Il client è stato chiuso.
`abstract void`	`clientReady(ClientImpl client)` Il client è pronto.
`static void`	`finishChunkPacket(JdwpPacket packet, int type, int chunkLen)` Scrivi l'intestazione del blocco all'inizio del blocco.
`static ByteBuffer`	`getChunkDataBuf(ByteBuffer jdwpBuf)` Restituisce la sezione del buffer dei pacchetti JDWP che contiene solo i dati del blocco.
`abstract void`	`handleChunk(ClientImpl client, int type, ByteBuffer data, boolean isReply, int msgId)` Gestisci un blocco in arrivo.
`void`	`handlePacket(ClientImpl client, JdwpPacket packet)`
`JdwpPacket`	`intercept(JdwpAgent agent, JdwpPacket packet)`
`static int`	`type(String typeName)` Converte una stringa di 4 caratteri in un tipo a 32 bit.

Metodi protetti
`void`	`handleUnknownChunk(ClientImpl client, int type, ByteBuffer data, boolean isReply, int msgId)` Frammenti di handle non riconosciuti dai gestori.

Costanti

CHUNK_HEADER_LEN

public static final int CHUNK_HEADER_LEN

Valore costante: 8 (0x00000008)

DDMS_CMD

public static final int DDMS_CMD

Constant Value: 1 (0x00000001)

DDMS_CMD_SET

public static final int DDMS_CMD_SET

Constant Value: 199 (0x000000c7)

Campi

CHUNK_FAIL

public static final int CHUNK_FAIL

CHUNK_ORDER

public static final ByteOrder CHUNK_ORDER

Costruttori pubblici

ChunkHandler

public ChunkHandler ()

Metodi pubblici

allocBuffer

public static ByteBuffer allocBuffer (int maxChunkLen)

Alloca un ByteBuffer con spazio sufficiente per contenere l'intestazione del pacchetto JDWP e un'intestazione del blocco oltre alle esigenze del blocco da creare.

"maxChunkLen" indica solo le dimensioni dei contenuti del chunk.

Parametri
`maxChunkLen`	`int`

Ritorni
`ByteBuffer`

clientDisconnected

public abstract void clientDisconnected (ClientImpl client)

Il client è stato chiuso. Può essere utilizzato per pulire le risorse associate a questa connessione client.

Parametri
`client`	`ClientImpl`

clientReady

public abstract void clientReady (ClientImpl client)

Il client è pronto. Il thread di monitoraggio chiama questo metodo su tutti i gestori quando il client viene considerato compatibile con DDM (di solito dopo aver ricevuto una risposta HELO).

Il gestore può utilizzare questa opportunità per inizializzare l'attività lato client. Poiché è molto probabile che vogliamo inviare un messaggio al client, questo metodo può generare un'eccezione IOException.

Parametri
`client`	`ClientImpl`

finishChunkPacket

public static void finishChunkPacket (JdwpPacket packet, 
                int type, 
                int chunkLen)

Scrivi l'intestazione del blocco all'inizio del blocco.

Passa il buffer di byte restituito da JdwpPacket.getPayload().

Parametri
`packet`	`JdwpPacket`
`type`	`int`
`chunkLen`	`int`

getChunkDataBuf

public static ByteBuffer getChunkDataBuf (ByteBuffer jdwpBuf)

Restituisce la sezione del buffer dei pacchetti JDWP che contiene solo i dati del blocco.

Parametri
`jdwpBuf`	`ByteBuffer`

Ritorni
`ByteBuffer`

handleChunk

public abstract void handleChunk (ClientImpl client, 
                int type, 
                ByteBuffer data, 
                boolean isReply, 
                int msgId)

Gestisci un blocco in arrivo. I dati, di tipo di blocco "type", iniziano all'inizio di "data" e continuano fino a data.limit().

Se "isReply" è impostato, "msgId" sarà l'ID della richiesta che abbiamo inviato al client. In caso contrario, è l'ID generato dal client per questo evento. Tieni presente che è possibile ricevere blocchi nei pacchetti di risposta per i quali non siamo registrati.

Il gestore non può modificare i contenuti di "data".

Parametri
`client`	`ClientImpl`
`type`	`int`
`data`	`ByteBuffer`
`isReply`	`boolean`
`msgId`	`int`

handlePacket

public void handlePacket (ClientImpl client, 
                JdwpPacket packet)

Parametri
`client`	`ClientImpl`
`packet`	`JdwpPacket`

intercetta

public JdwpPacket intercept (JdwpAgent agent, 
                JdwpPacket packet)

Parametri
`agent`	`JdwpAgent`
`packet`	`JdwpPacket`

Ritorni
`JdwpPacket`

digita

public static int type (String typeName)

Converte una stringa di 4 caratteri in un tipo a 32 bit.

Parametri
`typeName`	`String`

Ritorni
`int`

Metodi protetti

handleUnknownChunk

protected void handleUnknownChunk (ClientImpl client, 
                int type, 
                ByteBuffer data, 
                boolean isReply, 
                int msgId)

Frammenti di handle non riconosciuti dai gestori. Il metodo handleChunk() nelle sottoclassi deve chiamare questo metodo se il tipo di chunk non viene riconosciuto.

Parametri
`client`	`ClientImpl`
`type`	`int`
`data`	`ByteBuffer`
`isReply`	`boolean`
`msgId`	`int`