Jak sprawdzić poprawność przesłanych danych (Android)

class ReceiveBuffer
{
    public final int BUFFER_SIZE = 1024;
    public byte[] Buffer;
    public int toReceive;
    public ByteArrayOutputStream bufStream;

    public ReceiveBuffer(int toRec)
    {
        Buffer = new byte[BUFFER_SIZE];
        toReceive = toRec;
        bufStream = new ByteArrayOutputStream(toRec); // Początkowy rozmiar w bajtach tablicy wewnętrznej.
    }

class ClientIn {

    Socket socket;
    byte[] lenBuffer;
    ReceiveBuffer buffer;

    public  ClientIn(Socket s) {
        socket = s;
        lenBuffer = new byte[4];
    }

    public Bitmap Receive() {

        try {
            InputStream stream = socket.getInputStream();
            stream.read(lenBuffer, 0, lenBuffer.length);    // Za pomocą tego read'a odczytuję wielkość tablicy którą chcę odczytać. Jako że chcę przekonwertować te dane na typ int to wielkość tablicy lenBuffer to 4

            buffer = new ReceiveBuffer(BitConverter.ToInt32(lenBuffer,0)) ; // Bitconvertera nie ma w Javie ale znalazłem w Internecie implementację która realizuje to jak w C# i działa poprawnie.
            while(buffer.toReceive > 0) {    
                stream.read(buffer.Buffer, 0, buffer.Buffer.length); // Odczytywanie właściwych danych związanych z obrazem
                if (buffer.Buffer.length <= 0) {
                    continue;
                }
                else {

                    if (buffer.toReceive < 1024) {    // Przy ostatniej iteracji pętli zazwyczaj ilość odczytanych danych jest mniejsza od 1024 więc dopisujemy do bufStream wartości z bufora o długości danych które nam pozostały i które są wskazywane przez toReceive
                        buffer.bufStream.write(buffer.Buffer, 0, buffer.toReceive); 
                        buffer.toReceive -= buffer.toReceive;
                        Arrays.fill(buffer.Buffer, 0, buffer.Buffer.length, (byte) 0); // Czyszczenie bufora

                    }
                    else {
                        buffer.bufStream.write(buffer.Buffer, 0, buffer.Buffer.length);
                        buffer.toReceive -= buffer.Buffer.length;      // Odejmujemy od ogólnej liczby bitów tyle bitów ile aktualnie pobraliśmy
                        if (buffer.toReceive > 0) {
                        Arrays.fill(buffer.Buffer, 0, buffer.Buffer.length, (byte) 0);
                        }
                    }
                }
            }

            byte[] test123 = buffer.bufStream.toByteArray();

            BitmapFactory.Options options = new BitmapFactory.Options();
            options.inJustDecodeBounds = true;
            BitmapFactory.decodeByteArray(test123, 0, test123.length, options);
            options.inSampleSize = calculateInSampleSize(options, 500, 500);
            options.inJustDecodeBounds = false;
            Bitmap thtImg2 = BitmapFactory.decodeByteArray(test123, 0, test123.length, options);
            return thtImg2;
        }
        catch (IOException e) {
            e.printStackTrace();
            return null;
        }
    }

    public static int calculateInSampleSize(BitmapFactory.Options options, int reqWidth, int reqHeight) {
        // Raw height and width of image
        final int height = options.outHeight;
        final int width = options.outWidth;
        int inSampleSize = 1;

        if (height > reqHeight || width > reqWidth) {

            final int halfHeight = height / 2;
            final int halfWidth = width / 2;

            // Calculate the largest inSampleSize value that is a power of 2 and keeps both
            // height and width larger than the requested height and width.
            while ((halfHeight / inSampleSize) > reqHeight || (halfWidth / inSampleSize) > reqWidth) {
                inSampleSize *= 2;
            }
        }
        return inSampleSize;
    }
}