Incorrect implementation of `JByteBuffer.array`

[brianquinlan]

This is with:

dependencies:
  jni: ^0.13.0

Repro:

import 'dart:typed_data';
import 'package:jni/jni.dart';

void main() {
    final l = Uint8List.fromList([1, 2, 3, 4]);
    final bb = JByteBuffer.fromList(l);

    print(l);
    print(bb.array);
    print(bb.array.getRange(0, 4));
}


Output:

[1, 2, 3, 4]
(0, 0, 0, 0, 1, 2, 3, 4, 0, 0, 0)
[0, 0, 0, 0]

[HosseinYousefi]

Docs: https://docs.oracle.com/javase/8/docs/api/java/nio/ByteBuffer.html

There are two kinds of JByteBuffer, direct and non-direct. Non-direct ones are backed by a normal Java array. Direct ones are created from native memory so bb is direct. bb.array should then throw an exception UnsupportedOperationException because it is not backed by an array:

  /// The array that backs this buffer.
  ///
  /// Concrete subclasses like [JByteBuffer] provide more strongly-typed return
  /// values for this method.
  ///
  /// Throws:
  /// * `ReadOnlyBufferException` - If this buffer is backed by an array but is
  ///   read-only
  /// * `UnsupportedOperationException` - If this buffer is not backed by an
  ///   accessible array
  JObject get array {
    return _arrayId(this, const JObjectType(), [])!;
  }

When I run the code on desktop this is what I get:

[1, 2, 3, 4]
Exception in Java code called through JNI: java.lang.UnsupportedOperationException

java.lang.UnsupportedOperationException
	at java.base/java.nio.ByteBuffer.array(ByteBuffer.java:1471)

but on an emulator I get your output! I don't know why!

[HosseinYousefi]

For what it's worth, native android apps are broken as well, so this seems to be a general android bug. Would you mind filing a bug for them?

[brianquinlan]

I think that the android behavior might be by design. The Android documentation does not mention UnsupportedOperationException, instead it says that hasArray should be called.

The docs for allocateDirect do not guarantee that the ByteBuffer has a backing array.

Also, there apparently you also have to use arrayOffset to get the offset of the first element.

To take a step back, my use case is converting between List<int>/Uint8List and JByteBuffer, ideally in the most efficient possible manner.

Probably it makes sense to have a JByteBuffer.fromList factory and an extension on Uint8List to convert to JByteBuffer.

What do you think? I'd be happy to do the work.

[HosseinYousefi]

I think that the android behavior might be by design. The Android documentation does not mention UnsupportedOperationException, instead it says that hasArray should be called.

It says that but if you look at the Throws table, it says that it will throw the exception if it's not array-backed!

Probably it makes sense to have a JByteBuffer.fromList factory and an extension on Uint8List to convert to JByteBuffer.

What do you think? I'd be happy to do the work.

JByteBuffer.fromList already exists, you are using it in your example. There is also an extension toJByteBuffer on Uint8List.

asUint8List also exists but that only works for direct byte buffers. We could also support converting array backed byte buffers to Uint8Lists but that would be a toUint8List (as opposed to as...) method as the resulting list is a copy.

[HosseinYousefi]

I guess the point is allocateDirect does not guarantee that the backing array does not exist.

I will add the point about hasArray and arrayOffset to array's doc comment.

[brianquinlan]

I actually meant JByteArray.fromList. I shouldn't try to do productive work so early in the morning ;-)

[HosseinYousefi]

I actually meant JByteArray.fromList. I shouldn't try to do productive work so early in the morning ;-)

Sure, that makes sense! This would work: JByteArray(list.length)..setRange(0, list.length, list). Feel free to open a PR!