The stack handles all characteristic reads and there is currently no callback into the app when processing a read request.
- The application writes characteristic values to GATT DB
- The peer reads from the GATT DB, but the application does not need to know how and when read is performed
- The peer writes to the GATT DB and an application callback is issued.
- The application can then read the data from the GATT DB
- If a write requires an acknowledgement, it is provided by the stack without application involvement
My consideration is that the Android app is only available up to write and read a characteristic value for 20 bytes, and therefore the client application require to write many times for a large BLOB characteristic value, and also the application should use the issued Write Callback in order to read a value from the GATT DB.
But on the other hand, when the client application require to read a large BLOB value from the GATT DB, What is good to write the large BLOB value by the application side, and also what is good to read the large BLOB value by the client application side? Should we need to define a new Write characteristic value in order to handshake between them although there are many resource required? Is there any good way to read the large BLOB value rapidly?
I've escalated this internally to the software team to see if they can provide guidance on the best method to read and write large BLOB values, or if this is even possible.
I checked with the software team and the method described does not exist yet, but we will try to patch it in within the next SDK release if the product team agrees it's a necessary feature.
Note that large BLOB will be fragmented into 20 byte packets anyway, so there is no real benefit other than a slight application convenience.
The application can easily create 512 bytes buffer and then read/write data into the buffer.