/**
 *  BlueCove - Java library for Bluetooth
 *  Copyright (C) 2004 Intel Corporation
 *
 *  Licensed to the Apache Software Foundation (ASF) under one
 *  or more contributor license agreements.  See the NOTICE file
 *  distributed with this work for additional information
 *  regarding copyright ownership.  The ASF licenses this file
 *  to you under the Apache License, Version 2.0 (the
 *  "License"); you may not use this file except in compliance
 *  with the License.  You may obtain a copy of the License at
 *
 *    http://www.apache.org/licenses/LICENSE-2.0
 *
 *  Unless required by applicable law or agreed to in writing,
 *  software distributed under the License is distributed on an
 *  "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
 *  KIND, either express or implied.  See the License for the
 *  specific language governing permissions and limitations
 *  under the License.
 *
 *  @version $Id: BluetoothRFCommOutputStream.java 2416 2008-10-09 17:59:55Z skarzhevskyy $
 */
package com.intel.bluetooth;

import java.io.IOException;
import java.io.OutputStream;

class BluetoothRFCommOutputStream extends OutputStream {

	volatile private BluetoothRFCommConnection conn;

	public BluetoothRFCommOutputStream(BluetoothRFCommConnection conn) {
		this.conn = conn;
	}

	/*
	 * Writes the specified byte to this output stream. The general contract for
	 * write is that one byte is written to the output stream. The byte to be
	 * written is the eight low-order bits of the argument b. The 24 high-order
	 * bits of b are ignored. Subclasses of OutputStream must provide an
	 * implementation for this method.
	 *
	 * Parameters: b - the byte. Throws: IOException - if an I/O error occurs.
	 * In particular, an IOException may be thrown if the output stream has been
	 * closed.
	 */

	public void write(int b) throws IOException {
		if (conn == null) {
			throw new IOException("Stream closed");
		} else {
			conn.bluetoothStack.connectionRfWrite(conn.handle, b);
		}
	}

	/*
	 * Writes len bytes from the specified byte array starting at offset off to
	 * this output stream. The general contract for write(b, off, len) is that
	 * some of the bytes in the array b are written to the output stream in
	 * order; element b[off] is the first byte written and b[off+len-1] is the
	 * last byte written by this operation. The write method of OutputStream
	 * calls the write method of one argument on each of the bytes to be written
	 * out. Subclasses are encouraged to override this method and provide a more
	 * efficient implementation.
	 *
	 * If b is null, a NullPointerException is thrown.
	 *
	 * If off is negative, or len is negative, or off+len is greater than the
	 * length of the array b, then an IndexOutOfBoundsException is thrown.
	 *
	 * Parameters: b - the data. off - the start offset in the data. len - the
	 * number of bytes to write. Throws: IOException - if an I/O error occurs.
	 * In particular, an IOException is thrown if the output stream is closed.
	 */
	public void write(byte[] b, int off, int len) throws IOException {
		if (off < 0 || len < 0 || off + len > b.length) {
			throw new IndexOutOfBoundsException();
		}

		if (conn == null) {
			throw new IOException("Stream closed");
		} else {
			conn.bluetoothStack.connectionRfWrite(conn.handle, b, off, len);
		}
	}

	public void flush() throws IOException {
		if (conn == null) {
			throw new IOException("Stream closed");
		} else {
			super.flush();
			conn.bluetoothStack.connectionRfFlush(conn.handle);
		}
    }

	/**
	 * Closes this output stream and releases any system resources associated
	 * with this stream.
	 * <p>
	 * The general contract of close is that it closes the output stream. A
	 * closed stream cannot perform output operations and cannot be reopened.
	 *
	 * @throws IOException
	 *             If an I/O error occurs
	 */
	public void close() throws IOException {
		// Function is not synchronized
		BluetoothRFCommConnection c = conn;
		if (c != null) {
			conn = null;
			c.streamClosed();
		}
	}

	boolean isClosed() {
		return this.conn == null;
	}
}