Estoy jugando con una aplicación de Android simple usando el emmulador ejecutando android-7 (2.1) y un androide-8 con ejecución de moto (2.2).defectos de implementación android java ... ¿están documentados?
Me encontré con un problema interesante por el cual una aplicación de análisis CSV falló en el emmulator, pero tuvo éxito en el desafío y en las aplicaciones Java normales (usando Sun Java).
Rastreé el problema hacia abajo y la causa es que de android-7 implementación de StringReader no admite una operación negativa salto:
Android-7:
/**
* Skips {@code amount} characters in the source string. Subsequent calls of
* {@code read} methods will not return these characters unless {@code
* reset()} is used.
*
* @param ns
* the maximum number of characters to skip.
* @return the number of characters actually skipped or 0 if {@code ns < 0}.
* @throws IOException
* if this reader is closed.
* @see #mark(int)
* @see #markSupported()
* @see #reset()
*/
@Override
public long skip(long ns) throws IOException {
synchronized (lock) {
if (isClosed()) {
throw new IOException(Msg.getString("K0083")); //$NON-NLS-1$
}
if (ns <= 0) {
return 0;
}
long skipped = 0;
if (ns < this.count - pos) {
pos = pos + (int) ns;
skipped = ns;
} else {
skipped = this.count - pos;
pos = this.count;
}
return skipped;
}
}
J2SE 1.6:
/**
* Skips the specified number of characters in the stream. Returns
* the number of characters that were skipped.
*
* <p>The <code>ns</code> parameter may be negative, even though the
* <code>skip</code> method of the {@link Reader} superclass throws
* an exception in this case. Negative values of <code>ns</code> cause the
* stream to skip backwards. Negative return values indicate a skip
* backwards. It is not possible to skip backwards past the beginning of
* the string.
*
* <p>If the entire string has been read or skipped, then this method has
* no effect and always returns 0.
*
* @exception IOException If an I/O error occurs
*/
public long skip(long ns) throws IOException {
synchronized (lock) {
ensureOpen();
if (next >= length)
return 0;
// Bound skip by beginning and end of the source
long n = Math.min(length - next, ns);
n = Math.max(-next, n);
next += n;
return n;
}
}
Por lo tanto, en lugar de saltar hacia atrás (el analizador usa esto para leer previamente un carácter en ciertos casos), la versión de Android permanece un carácter hacia adelante.
Mi pregunta es, ¿las diversas incompatibilidades y variaciones de la especificación J2SE están documentadas en alguna parte? Si no, ¿con qué otros problemas se encuentran?
Gracias, p.