The articles
Multipeer Connectivity Near-field multipoint communication implements a simple sandbox file browser implements a simple breadcrumb navigation
IO stream
Introduction to the
Input/Output refers to the Input and Output, centered on memory
Input refers to reading data from the outside into memory, for example, reading data from disk or network into memory
Output refers to writing data from memory to the outside world, such as writing data from memory to the network
The data has to be in memory to be processed, because the code is running in memory, the data has to be read into memory, and it ends up showing up as an array of bytes, or an array of strings
IO flow is a pattern of sequential reading and writing data. It is characterized by one-way flow. Data flows in a water pipe like running water, so we call it an IO stream.
Usage scenarios
When our programs copy files from one place to another, they often need to be read into memory
Directly read
If we just use the way below, we first convert the network video into NSData and save it in memory, and then write the NSData in memory into the sandbox and save it.
In this way, when the video is only tens of meters, it will not have a big impact. If the video is several GIGABytes, several GIGABytes of NSData data will be written into our memory temporarily, which will occupy a lot of running memory. In the case of insufficient running memory of mobile phone, crash will be caused.
Use the stream
For example, if we carry water in a bucket, if we need to carry a lot of water at one time, we need to use a bigger bucket. It would be a lot easier if we had a pipe connecting the outlet to the pool, and we could move the water from one place to another without too much effort.
Data flow is a similar concept. We compare data to water, flow to pipe, and memory to power a pump. In this way, there is no memory explosion due to too much data, and the fast read performance of memory can be used to improve efficiency.
So a stream is like a pipe in memory that allows the output file and the input file to flow in one direction.
IO streams in IOS
NSStream
Is an abstract class that defines the interface for manipulating a stream in iOS. A stream can also be understood as an object in objC, where everything is an object
Provides a simple way to read and write data from a variety of media in a device-independent manner. You can create stream objects for data that is in memory, a file, or a network (using sockets), and you can use stream objects without having to load all the data into memory at once
The interfaces are defined as follows
Open and close
Open Opens the stream for reading or writing. If the stream object is added to the runloop, the stream object’s delegate method takes effect
To close a stream, note that the stream cannot be opened again after being closed
delegate
Delegate the stream object. Note that the stream object must be added to the Runloop in order for the principal to receive information from the stream object.
ScheduleInRunLoop: forMode: and removeFromRunLoop: forMode:
ScheduleInRunLoop: forMode: objects are added to the runloop will flow
RemoveFromRunLoop: forMode: object is removed from the runloop will flow
PropertyForKey: and setProperty: forKey
Sets and gets property values in the NSStream stream object
StreamStatus and streamError
The transmission status and error code of the stream object
NSSInputStream
NSStream is an abstract class that does not instantiate objects, but defines a set of implementation standards.
Its subclass NSSInputStream implements the reading function of the stream object, which is equivalent to the pumping function in our water pipe model. It is mainly used to write data to a stream object.
The main methods used are as follows
Read buffer
Taking the water pipe model as an example, in real life we can actually have a piece of water pipe, but in memory we can’t really build a pipe, so we need to use the buffer to achieve the effect of pipe. The cache is limited in size and read length, that is, the size of the pipe and the speed of the water flow. Only data read into the buffer can be sent to the writing end
read:maxLength:
Method of reading data,
-
The first argument, buf, represents the read buffer and is a pointer to Int8, since we know that 8 bits are a byte.
-
The second parameter: maxLength represents the maximum length of data to be read from the buffer each time.
-
Return value: indicates the number of bytes read. Generally, it is equal to maxLength. If the remaining data in the buffer is smaller than maxLength, the return value is smaller than maxLength, indicating that the data in the buffer is read.
getBuffer:length:
Gets the data and size in the current stream
-
First argument: a pointer to the read buffer
-
Second argument: read the number of bytes available in the buffer
-
Return value: is a BOOL
YES if the buffer is available, NO otherwise
hasBytesAvailable
Return YES if there is more data to read from the stream, and NO if there is none
use
Cyclic read mode
This method uses a primitive loop that reads the file data extracted from InputStream into the buffer one at a time. A buffer used to write a large file into segments that are inserted into the next segment after the buffer has read one segment. But if it’s in the main thread it’s going to cause a UI wait. So put it in a child thread again.
func setupInputStream(a){
// Set the path to read the file
let input = InputStream.init(fileAtPath: path)
input?.open()
let readLength = 32;
let buf = UnsafeMutablePointer<UInt8>.allocate(capacity: readLength);
while true {
let bytes = input?.read(buf, maxLength: readLength)
if bytes! < readLength {
break
}
}
input?.close()
buf.deallocate()
}
Copy the codeNote that in Swift integer array Pointers are held using an UnsafeMutablePointer and therefore are not automatically GC, so we need to release them manually, otherwise we will leak memory
Runloop mode
From the above pattern, we found that the write stream (NSInputStream) needs to read the file one by one through the cache, so a loop is needed to perform the read, but as far as we know, IOS has an extremely powerful loop called RunLoop. So we can use the features of Runloop to help us use high-quality loops to get the stream objects to read data
After adding the stream object to the runloop, I can get the state of the stream read by implementing the NSStream delegate.
// Get the resource address
func setupInputStream(a){
let path = self.getResource()
// Create an input stream to set the path to read the file
let inputStream = InputStream.init(fileAtPath: path)
self.inputStream = inputStream;
inputStream?.delegate = self;
// Add a run loop to the stream object
inputStream?.schedule(in: RunLoop.current, forMode: .common)
// Open the input stream object
inputStream?.open();
}
func stream(_ aStream: Stream.handle eventCode: Stream.Event) {
switch eventCode {
case .openCompleted: // The stream object was opened successfully
print("Stream object opened successfully")
case .hasBytesAvailable: // The stream object has data to read (NSSInputStream)
let maxLength = 4*1024
let buf = UnsafeMutablePointer<UInt8>.allocate(capacity: maxLength);
self.inputStream!.read(buf, maxLength: maxLength)
buf.deallocate()
buf.deinitialize(count: maxLength)
case .hasSpaceAvailable: // There is space for the stream object to write buffer (NSOuputStream)
case .endEncountered: // The stream object completes the data reading
aStream.close()
aStream.remove(from: RunLoop.current, forMode: .common)
case .errorOccurred: // Error reading data from stream object
print("Error reading data from stream object")
default: break}}Copy the codeNSOutputStream
It is also a subclass of NSStream, which implements the write function of stream objects. It is equivalent to the water discharge function in the water pipe model.
Write buffer
A buffer used to write data to an NSOutputStream in the same way as a read buffer. Used to provide external data read by NSOutputStream
write:maxLength:
Write data method,
-
The first argument: buf stands for write buffer, is a pointer, because we know that 8 bits is a byte, so is an array pointer to Int8.
-
The second parameter: maxLength represents the maximum length of data to be read from the buffer each time.
-
Return value: indicates the number of bytes written to the buffer. Generally speaking, it is equal to the maximum read length of the buffer. If the remaining data in the buffer is smaller than maxLength, the return value is smaller than maxLength, indicating that the data in the buffer is read.
hasSpaceAvailable
YES indicates that data can be written to the current stream. NO indicates that data cannot be written to the current stream
use
Cyclic read mode
The principle is the same as the read stream, but also according to the buffer size of the loop to read. Also be careful to release variables that do not support automatic GC. Avoiding memory leaks
func setupOutputStream(a) {
let output = OutputStream.init(url: writeResource(), append: false)
output?.open()
let readLength = 32;
let buf = UnsafeMutablePointer<UInt8>.allocate(capacity: readLength);
while true {
let bytes = outputStream?.write(buf, maxLength: readLength)
if bytes! < readLength {
break
}
}
output?.close()
buf.deallocate()
}
Copy the codeRunloop mode
func setupInputStream(a){
// Create the output stream output file address
let fileUrl = writeResource()
// Create an output stream
let outputStream = OutputStream.init(url: fileUrl as URL, append: false)
self.outputStream = outputStream;
outputStream?.delegate = self
outputStream?.schedule(in: RunLoop.current, forMode: .common)
outputStream?.open()
}
func stream(_ aStream: Stream.handle eventCode: Stream.Event) {
switch eventCode {
case .openCompleted: // The stream object was opened successfully
print("Stream object opened successfully")
case .hasBytesAvailable: // The stream object has data to read (NSSInputStream)
case .hasSpaceAvailable: // There is room for writing to the stream object (NSOuputStream)
let maxLength = 4*1024
let buf = UnsafeMutablePointer<UInt8>.allocate(capacity: maxLength);
self.outputStream?.write(buf, maxLength: maxLength)
buf.deallocate()
buf.deinitialize(count: maxLength)
case .endEncountered: // The stream object completes the data reading
aStream.close()
aStream.remove(from: RunLoop.current, forMode: .common)
case .errorOccurred: // Error reading data from stream object
print("Error reading data from stream object")
default: break}}Copy the codeComplete IO stream reading example
Here we test whether using and not using IO streams results in running memory inflation by reading a 70MB video
We write videos from the project resources directory to the application directory to observe memory changes with and without IO stream
IO streams are not used
The file is read directly into memory and then written to the sandbox
We can observe that the memory suddenly increases several times
Use the IO stream
After using the IO stream, we found that the memory changes very smoothly, indicating that there is no large amount of data suddenly flooded into memory, files are read through our IO stream built pipe from the send position to the receive position bit by bit
Read and write flow code
func openIOStream(a) {
// Get the resource address
let path = self.getResource()
// // Create an input stream
let inputStream = InputStream.init(fileAtPath: path)
self.inputStream = inputStream;
inputStream?.delegate = self;
// Add a run loop to the stream object
inputStream?.schedule(in: RunLoop.current, forMode: .common)
// Open the input stream object
inputStream?.open();
// Create the output stream output file address
let fileUrl = writeResource()
// Create an output stream
let outputStream = OutputStream.init(url: fileUrl as URL, append: false)
self.outputStream = outputStream;
outputStream?.delegate = self
outputStream?.schedule(in: RunLoop.current, forMode: .common)
outputStream?.open()
}
func stream(_ aStream: Stream.handle eventCode: Stream.Event) {
switch eventCode {
case .openCompleted: // The stream object was opened successfully
print("Stream object opened successfully")
case .hasBytesAvailable: // The stream object has data to read (NSSInputStream)
let maxLength = 4*1024
let buf = UnsafeMutablePointer<UInt8>.allocate(capacity: maxLength);
self.inputStream!.read(buf, maxLength: maxLength)
buf.deallocate()
buf.deinitialize(count: maxLength)
case .hasSpaceAvailable: // There is room for writing to the stream object (NSOuputStream)
let maxLength = 4*1024
let buf = UnsafeMutablePointer<UInt8>.allocate(capacity: maxLength);
self.outputStream?.write(buf, maxLength: maxLength)
buf.deallocate()
buf.deinitialize(count: maxLength)
case .endEncountered: // The stream object completes the data reading
self.inputStream?.close()
self.inputStream?.remove(from: RunLoop.current, forMode: .common)
self.outputStream?.close()
self.outputStream?.remove(from: RunLoop.current, forMode: .common)
case .errorOccurred: // Error reading data from stream object
print("Error reading data from stream object")
default: break}}Copy the code