/**
* Construct a frequency table from an InputStream. This will create a temporary file to copy the
* InputStream in.
*
* @param source the Input Stream
* @return an InputStream which is a copy of the source Stream, provided to re-Read the same Bytes
* for the actual compression process.
*/
public InputStream constructTable(InputStream source, boolean copy) {
freq = new int[TABLESIZE];
try {
File file = null;
FileOutputStream fos = null;
if (copy == true) {
file = File.createTempFile("huf", "tmp");
file.deleteOnExit();
fos = new FileOutputStream(file);
}
while (source.available() != 0) {
int c = source.read();
freq[c]++;
if (copy) fos.write(c);
}
source.close();
if (copy) {
fos.close();
return new FileInputStream(file);
}
return null;
} catch (Exception ex) {
ExHandler.handle(ex);
return null;
}
}
public void run(String local, String remote, InputStream pin, OutputStream pout) {
try {
microphone = SoundMixerEnumerator.getInputLine(pcmformat, DefaultPhonePCMBlockSize);
} catch (LineUnavailableException lue) {
System.out.println(
"\3b"
+ getClass().getName()
+ ".<init>:\n\tCould not create microphone input stream.\n\t"
+ lue);
}
try {
speaker = SoundMixerEnumerator.getOutputLine(pcmformat, DefaultPhonePCMBlockSize);
} catch (LineUnavailableException lue) {
microphone.close();
System.out.println(
"\3b"
+ getClass().getName()
+ ".<init>:\n\tCould not create speaker output stream.\n\t"
+ lue);
}
if ((speaker == null) || (microphone == null)) {
super.run(local, remote, pin, pout);
return;
}
try {
recorder = new Recorder(pout);
recorder.start();
gui = openMonitorGUI("Remote " + remote + " Local " + local);
pin.skip(pin.available()); // waste whatever we couldn't process in time
super.run(local, remote, new PhoneCallMonitorInputStream(pin), pout);
recorder.interrupt();
gui.dispose();
} catch (Exception e) {
System.out.println("3\b" + getClass().getName() + ".run:\n\t" + e);
e.printStackTrace();
} finally {
deactivate();
microphone.close();
speaker.close();
if (gui != null) {
gui.dispose();
}
}
}
private String getStringFromStreamSource(StreamSource src, int length) throws Exception {
byte buf[] = null;
if (src == null) return null;
InputStream outStr = src.getInputStream();
if (outStr != null) {
int len = outStr.available();
if (outStr.markSupported()) outStr.reset();
buf = new byte[len];
outStr.read(buf, 0, len);
// System.out.println("From inputstream: "+new String(buf));
return new String(buf);
} else {
char buf1[] = new char[length];
Reader r = src.getReader();
if (r == null) return null;
r.reset();
r.read(buf1);
// System.out.println("From Reader: "+new String(buf));
return new String(buf1);
}
}
private boolean unpackFile(ZipFile zip, byte[] buf, ZipEntry fileEntry, String name)
throws IOException, FileNotFoundException {
if (fileEntry == null) fileEntry = zip.getEntry(name);
if (fileEntry == null)
throw new FileNotFoundException("Can't find " + name + " in " + zip.getName());
File outFile = new File(sGREDir, name);
if (outFile.lastModified() == fileEntry.getTime() && outFile.length() == fileEntry.getSize())
return false;
File dir = outFile.getParentFile();
if (!dir.exists()) dir.mkdirs();
InputStream fileStream;
fileStream = zip.getInputStream(fileEntry);
OutputStream outStream = new FileOutputStream(outFile);
while (fileStream.available() > 0) {
int read = fileStream.read(buf, 0, buf.length);
outStream.write(buf, 0, read);
}
fileStream.close();
outStream.close();
outFile.setLastModified(fileEntry.getTime());
return true;
}
@Transactional
public DeviceTestData parseAndSaveBBIFile(
InputStream inputStream, String verificationID, String originalFileName)
throws IOException, DecoderException {
BufferedInputStream bufferedInputStream = new BufferedInputStream(inputStream);
bufferedInputStream.mark(inputStream.available());
DeviceTestData deviceTestData =
bbiFileService.parseBbiFile(bufferedInputStream, originalFileName);
bufferedInputStream.reset();
calibratorService.uploadBbi(bufferedInputStream, verificationID, originalFileName);
return deviceTestData;
}
/**
* compute a frequency table from an InputStream and save a compacted representation of this table
* in the system preferences. (To be used later by @see #useStandardTable(String) )
*
* @param name name to give the table.
* @param in InputStream
* @return true on success
* @throws Exception
*/
public static boolean CreateStandardTableFromStream(String name, InputStream in)
throws Exception {
int[] tbl = new int[TABLESIZE];
while (in.available() != 0) {
int c = in.read();
tbl[c]++;
}
byte[] dest = HuffmanTree.compactTable(tbl);
Preferences pref = Preferences.userNodeForPackage(Huff.class);
Preferences node = pref.node("StandardTables");
node.putByteArray(name, dest);
pref.flush();
return true;
}
/**
* Returns the byte representation of the image corresponding to the given identifier.
*
* @param imageID the identifier of the image
* @return the byte representation of the image corresponding to the given identifier.
*/
private static byte[] getImageInBytes(String imageID) {
InputStream in = getResources().getImageInputStream(imageID);
if (in == null) return null;
byte[] image = null;
try {
image = new byte[in.available()];
in.read(image);
} catch (IOException e) {
logger.error("Failed to load image:" + imageID, e);
}
return image;
}
private static int readInputStreamWithTimeout(InputStream is, byte[] b, int timeoutMillis)
throws IOException {
try {
int bufferOffset = 0;
long maxTimeMillis = System.currentTimeMillis() + timeoutMillis;
while (System.currentTimeMillis() < maxTimeMillis && bufferOffset < b.length) {
int readLength = java.lang.Math.min(is.available(), b.length - bufferOffset);
int readResult = is.read(b, bufferOffset, readLength);
if (readResult == -1) break;
bufferOffset += readResult;
}
return bufferOffset;
} catch (IOException ex) {
Loggers.SERVER.error("Error reading stream. Stream closed: " + ex);
return -1;
}
}
/** Write the given resource as an http response body. */
public boolean write(String filename, HttpExchange t) throws IOException {
InputStream stream = getInputStream(filename);
if (stream != null) {
Headers headers = t.getResponseHeaders();
if (!headers.containsKey("Content-Type")) {
String mime = getContentType(filename);
if (mime != null) {
headers.add("Content-Type", mime);
}
}
// Note: available() isn't officially guaranteed to return the full
// stream length but effectively seems to do so in our context.
t.sendResponseHeaders(200, stream.available());
dump(stream, t.getResponseBody());
return true;
}
return false;
}
/**
* Returns the given input stream as a byte array
*
* @param stream the stream to get as a byte array
* @param length the length to read from the stream or -1 for unknown
* @return the given input stream as a byte array
* @throws IOException
*/
public static byte[] getInputStreamAsByteArray(InputStream stream, int length)
throws IOException {
byte[] contents;
if (length == -1) {
contents = new byte[0];
int contentsLength = 0;
int amountRead = -1;
do {
// read at least 8K
int amountRequested = Math.max(stream.available(), 8192);
// resize contents if needed
if (contentsLength + amountRequested > contents.length) {
System.arraycopy(
contents,
0,
contents = new byte[contentsLength + amountRequested],
0,
contentsLength);
}
// read as many bytes as possible
amountRead = stream.read(contents, contentsLength, amountRequested);
if (amountRead > 0) {
// remember length of contents
contentsLength += amountRead;
}
} while (amountRead != -1);
// resize contents if necessary
if (contentsLength < contents.length) {
System.arraycopy(contents, 0, contents = new byte[contentsLength], 0, contentsLength);
}
} else {
contents = new byte[length];
int len = 0;
int readSize = 0;
while ((readSize != -1) && (len != length)) {
// See PR 1FMS89U
// We record first the read size. In this case length is the actual
// read size.
len += readSize;
readSize = stream.read(contents, len, length - len);
}
}
return contents;
}
public byte[] getBytes(String className) {
try {
Tracer.mark();
String realName = className.replace(".", "/");
realName += ".class";
JarEntry je = jf.getJarEntry(realName);
InputStream is = jf.getInputStream(je);
ByteArrayOutputStream baos = new ByteArrayOutputStream();
byte[] buff = new byte[4096];
while (is.available() > 0) {
int read = is.read(buff);
baos.write(buff, 0, read);
}
is.close();
return baos.toByteArray();
} catch (Exception e) {
} finally {
Tracer.unmark();
}
return null;
}
/*
* Read a single pair of (X,Y) values from the ADXL202EVB board.
* TODO: Better return value, or declare as throwing exception for errs
*/
public static double[] chipRead() {
double[] retval = {0.0, 0.0};
byte[] rawBuf = {0, 0, 0, 0};
int[] vals = {0, 0};
try {
// Read is triggered by sending 'G' to board
outputStream.write('G');
// Wait for all 4 result bytes to arrive
// TODO: Finite wait w/error return if data never arrives
while (inputStream.available() < 4) {
Thread.sleep(1);
}
inputStream.read(rawBuf, 0, 4);
// Convert from raw bytes to 16-bit signed integers, carefully
Byte bTmp = new Byte(rawBuf[0]);
vals[0] = bTmp.intValue() * 256;
bTmp = new Byte(rawBuf[1]);
vals[0] += bTmp.intValue();
bTmp = new Byte(rawBuf[2]);
vals[1] = bTmp.intValue() * 256;
bTmp = new Byte(rawBuf[3]);
vals[1] += bTmp.intValue();
// See ADXL202EVB specs for details on conversion
retval[0] = (((vals[0] / 100.0) - 50.0) / 12.5);
retval[1] = (((vals[1] / 100.0) - 50.0) / 12.5);
System.out.println("X: " + retval[0] + " Y: " + retval[1]);
} catch (Exception ioe) {
System.out.println("Error on data transmission");
}
return (retval);
}
public int available() throws IOException {
return is.available();
}
@Override
public int available() throws IOException {
return in.available();
}
String ReadFromStream() throws IOException {
String s = new String("");
while ((is.available() > 0) && (s.length() < 255)) s = s + String.valueOf((char) is.read());
System.out.println("Read: " + s);
return s;
}
/*////////////////////////////
private AssetManager getAssets() {
// TODO Auto-generated method stub
return null;
}
*/
static int VxCopyAsssetToSdcard(
String strFileSrc,
String strFileDest,
AssetManager assetmanager,
boolean bDontCopyIfExistsAndSameSize) {
int iSrcFileSize = 0;
int iDestFileSize = 0;
InputStream oInputStream = null;
OutputStream oOutputStream = null;
// get src file size and stream
try {
oInputStream = assetmanager.open(strFileSrc);
if (null != oInputStream) {
iSrcFileSize = oInputStream.available();
} else {
Log.e("", "ERROR: VxCopyResourceToSdcard could not open file " + strFileSrc);
return -1;
}
} catch (IOException e) {
Log.e("", "ERROR: VxCopyResourceToSdcard could not open file " + strFileSrc);
// TODO Auto-generated catch block
e.printStackTrace();
return -1;
}
if (bDontCopyIfExistsAndSameSize) {
// get dest file size and stream
try {
InputStream oTmpStream = null;
File readFile = new File(strFileDest);
oTmpStream = new FileInputStream(readFile);
;
if (null != oTmpStream) {
iDestFileSize = oTmpStream.available();
oTmpStream.close();
} else {
Log.e("", "ERROR: VxCopyAsssetToSdcard could not get size of file " + strFileDest);
return -1;
}
} catch (IOException e) {
Log.e("", "VxCopyAsssetToSdcard dest file doesnt exist.. will copy " + strFileSrc);
}
}
if (bDontCopyIfExistsAndSameSize && (iSrcFileSize == iDestFileSize)) {
Log.i("", "VxCopyAsssetToSdcard file exists " + strFileDest);
return 0;
}
// Read the entire asset into a local byte buffer.
byte[] buffer = new byte[iSrcFileSize];
try {
oInputStream.read(buffer);
oInputStream.close();
} catch (IOException e) {
Log.e("", "ERROR: VxCopyAsssetToSdcard could not read file " + strFileSrc);
// TODO Auto-generated catch block
e.printStackTrace();
}
// write buffer to destination file
try {
File oWriteFile = new File(strFileDest);
try {
oWriteFile.createNewFile();
} catch (IOException e) {
Log.e("", "error creating file " + strFileDest, e);
e.printStackTrace();
return -1;
}
oOutputStream = new FileOutputStream(oWriteFile);
// Don’t forget to close stream
if (oOutputStream != null) {
try {
oOutputStream.write(buffer);
oOutputStream.flush();
oOutputStream.close();
Log.i("", "Success copying file " + strFileDest + " size " + iSrcFileSize);
} catch (IOException e) {
Log.e("", "ERROR: VxCopyResourceToSdcard could not write file " + strFileDest);
e.printStackTrace();
return -1;
}
}
} catch (IOException e) {
Log.e("", "ERROR: VxCopyAsssetToSdcard could not read file " + strFileSrc);
// TODO Auto-generated catch block
e.printStackTrace();
return -1;
}
return 0;
}
/** Parse a manifest from a stream */
public Manifest(InputStream is) throws IOException {
while (is.available() != 0) {
MessageHeader m = new MessageHeader(is);
entries.addElement(m);
}
}
public synchronized void serialEvent(SerialPortEvent oEvent) {
if (oEvent.getEventType() == SerialPortEvent.DATA_AVAILABLE) {
try {
int available = input.available();
if (count < BUF_SIZE) {
count =
count
+ input.read(
buf, count, (available > BUF_SIZE - count) ? BUF_SIZE - count : available);
}
start = newline;
for (int i = newline; i <= count; i++) {
if (buf[i] == 'U' || buf[i] == '$') { // start byte
start = i;
break;
}
}
for (int i = start; i <= count; i++) {
if (buf[i] == '\n') { // end byte
newline = i;
break;
}
}
if (newline <= start) {
if (count == BUF_SIZE) { // buf full an no valid datagram found, clear the buffer
// need to copy the stuff after the start byte to the beginning
if ((count - start) <= 128) {
System.arraycopy(buf, start, buf, 0, count - start);
count = count - start;
start = 0;
newline = 0;
} else { // buf full and last start byte is more than max packet size clear all of the
// buffer
count = 0; // no need to copy since the buf is grabage
start = 0;
newline = 0;
}
}
return;
}
if (buf[start] == '$') {
buf[newline] = '\0';
System.out.println(new String(buf, start + 1, newline - start));
}
// found valid datagram
// parse datagram comma delimited
buf[newline] = ',';
String newbuf = new String(buf, start, newline - start);
StringTokenizer st = new StringTokenizer(newbuf, ",");
int[] data = new int[5];
int i = 0;
while (st.hasMoreElements() && i < 5) {
String temp = st.nextToken();
try {
data[i] = Integer.parseInt(temp, 16);
} catch (NumberFormatException e) {
}
i++;
}
RobotEvent ev = new RobotEvent();
int checksum;
ev.setCommand(EventEnum.getEvent(data[1]));
ev.setIndex((short) data[2]);
ev.setValue((int) data[3]);
checksum = data[4];
int checksum2 =
(int)
(((int) (ev.getCommand().getValue() & 0x000000FF)
+ (int) (ev.getIndex() & 0x000000FF)
+ (int) (ev.getValue() & 0x000000FF)
+ (int) ((ev.getValue() & 0x0000FF00) >> 8))
% 256);
if (checksum2 == checksum) {
// log event received
recv.put(ev);
}
} catch (Exception e) {
}
}
}