/* |
File: SendController.m |
|
Contains: Manages the Send tab. |
|
Written by: DTS |
|
Copyright: Copyright (c) 2009-2012 Apple Inc. All Rights Reserved. |
|
Disclaimer: IMPORTANT: This Apple software is supplied to you by Apple Inc. |
("Apple") in consideration of your agreement to the following |
terms, and your use, installation, modification or |
redistribution of this Apple software constitutes acceptance of |
these terms. If you do not agree with these terms, please do |
not use, install, modify or redistribute this Apple software. |
|
In consideration of your agreement to abide by the following |
terms, and subject to these terms, Apple grants you a personal, |
non-exclusive license, under Apple's copyrights in this |
original Apple software (the "Apple Software"), to use, |
reproduce, modify and redistribute the Apple Software, with or |
without modifications, in source and/or binary forms; provided |
that if you redistribute the Apple Software in its entirety and |
without modifications, you must retain this notice and the |
following text and disclaimers in all such redistributions of |
the Apple Software. Neither the name, trademarks, service marks |
or logos of Apple Inc. may be used to endorse or promote |
products derived from the Apple Software without specific prior |
written permission from Apple. Except as expressly stated in |
this notice, no other rights or licenses, express or implied, |
are granted by Apple herein, including but not limited to any |
patent rights that may be infringed by your derivative works or |
by other works in which the Apple Software may be incorporated. |
|
The Apple Software is provided by Apple on an "AS IS" basis. |
APPLE MAKES NO WARRANTIES, EXPRESS OR IMPLIED, INCLUDING |
WITHOUT LIMITATION THE IMPLIED WARRANTIES OF NON-INFRINGEMENT, |
MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, REGARDING |
THE APPLE SOFTWARE OR ITS USE AND OPERATION ALONE OR IN |
COMBINATION WITH YOUR PRODUCTS. |
|
IN NO EVENT SHALL APPLE BE LIABLE FOR ANY SPECIAL, INDIRECT, |
INCIDENTAL OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED |
TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
DATA, OR PROFITS; OR BUSINESS INTERRUPTION) ARISING IN ANY WAY |
OUT OF THE USE, REPRODUCTION, MODIFICATION AND/OR DISTRIBUTION |
OF THE APPLE SOFTWARE, HOWEVER CAUSED AND WHETHER UNDER THEORY |
OF CONTRACT, TORT (INCLUDING NEGLIGENCE), STRICT LIABILITY OR |
OTHERWISE, EVEN IF APPLE HAS BEEN ADVISED OF THE POSSIBILITY OF |
SUCH DAMAGE. |
|
*/ |
|
#import "SendController.h" |
|
#import "NetworkManager.h" |
#import "QNetworkAdditions.h" |
|
enum { |
kSendBufferSize = 32768 |
}; |
|
@interface SendController () <NSStreamDelegate> |
|
// stuff for IB |
|
@property (nonatomic, strong, readwrite) IBOutlet UILabel * statusLabel; |
@property (nonatomic, strong, readwrite) IBOutlet UIActivityIndicatorView * activityIndicator; |
@property (nonatomic, strong, readwrite) IBOutlet UIButton * cancelButton; |
|
- (IBAction)sendAction:(UIView *)sender; |
- (IBAction)cancelAction:(id)sender; |
|
// private properties |
|
@property (nonatomic, assign, readonly ) BOOL isSending; |
@property (nonatomic, strong, readwrite) NSOutputStream * networkStream; |
@property (nonatomic, strong, readwrite) NSInputStream * fileStream; |
@property (nonatomic, assign, readonly ) uint8_t * buffer; |
@property (nonatomic, assign, readwrite) size_t bufferOffset; |
@property (nonatomic, assign, readwrite) size_t bufferLimit; |
|
@end |
|
@implementation SendController |
{ |
uint8_t _buffer[kSendBufferSize]; |
} |
|
@synthesize networkStream = _networkStream; |
@synthesize fileStream = _fileStream; |
@synthesize bufferOffset = _bufferOffset; |
@synthesize bufferLimit = _bufferLimit; |
|
@synthesize statusLabel = _statusLabel; |
@synthesize activityIndicator = _activityIndicator; |
@synthesize cancelButton = _stopButton; |
|
#pragma mark * Status management |
|
// These methods are used by the core transfer code to update the UI. |
|
- (void)sendDidStart |
{ |
self.statusLabel.text = @"Sending"; |
self.cancelButton.enabled = YES; |
[self.activityIndicator startAnimating]; |
[[NetworkManager sharedInstance] didStartNetworkOperation]; |
} |
|
- (void)updateStatus:(NSString *)statusString |
{ |
assert(statusString != nil); |
self.statusLabel.text = statusString; |
} |
|
- (void)sendDidStopWithStatus:(NSString *)statusString |
{ |
if (statusString == nil) { |
statusString = @"Send succeeded"; |
} |
self.statusLabel.text = statusString; |
self.cancelButton.enabled = NO; |
[self.activityIndicator stopAnimating]; |
[[NetworkManager sharedInstance] didStopNetworkOperation]; |
} |
|
#pragma mark * Core transfer code |
|
// This is the code that actually does the networking. |
|
// Because buffer is declared as an array, you have to use a custom getter. |
// A synthesised getter doesn't compile. |
|
- (uint8_t *)buffer |
{ |
return self->_buffer; |
} |
|
- (BOOL)isSending |
{ |
return (self.networkStream != nil); |
} |
|
- (void)startSend:(NSString *)filePath |
{ |
NSOutputStream * output; |
BOOL success; |
NSNetService * netService; |
|
assert(filePath != nil); |
|
assert(self.networkStream == nil); // don't tap send twice in a row! |
assert(self.fileStream == nil); // ditto |
|
// Open a stream for the file we're going to send. |
|
self.fileStream = [NSInputStream inputStreamWithFileAtPath:filePath]; |
assert(self.fileStream != nil); |
|
[self.fileStream open]; |
|
// Open a stream to the server, finding the server via Bonjour. Then configure |
// the stream for async operation. |
|
netService = [[NSNetService alloc] initWithDomain:@"local." type:@"_x-SNSUpload._tcp." name:@"Test"]; |
assert(netService != nil); |
|
// Until <rdar://problem/6868813> is fixed, we have to use our own code to open the streams |
// rather than call -[NSNetService getInputStream:outputStream:]. See the comments in |
// QNetworkAdditions.m for the details. |
|
success = [netService qNetworkAdditions_getInputStream:NULL outputStream:&output]; |
assert(success); |
|
self.networkStream = output; |
self.networkStream.delegate = self; |
[self.networkStream scheduleInRunLoop:[NSRunLoop currentRunLoop] forMode:NSDefaultRunLoopMode]; |
|
[self.networkStream open]; |
|
// Tell the UI we're sending. |
|
[self sendDidStart]; |
} |
|
- (void)stopSendWithStatus:(NSString *)statusString |
{ |
if (self.networkStream != nil) { |
self.networkStream.delegate = nil; |
[self.networkStream removeFromRunLoop:[NSRunLoop currentRunLoop] forMode:NSDefaultRunLoopMode]; |
[self.networkStream close]; |
self.networkStream = nil; |
} |
if (self.fileStream != nil) { |
[self.fileStream close]; |
self.fileStream = nil; |
} |
self.bufferOffset = 0; |
self.bufferLimit = 0; |
[self sendDidStopWithStatus:statusString]; |
} |
|
- (void)stream:(NSStream *)aStream handleEvent:(NSStreamEvent)eventCode |
// An NSStream delegate callback that's called when events happen on our |
// network stream. |
{ |
assert(aStream == self.networkStream); |
#pragma unused(aStream) |
|
switch (eventCode) { |
case NSStreamEventOpenCompleted: { |
[self updateStatus:@"Opened connection"]; |
} break; |
case NSStreamEventHasBytesAvailable: { |
assert(NO); // should never happen for the output stream |
} break; |
case NSStreamEventHasSpaceAvailable: { |
[self updateStatus:@"Sending"]; |
|
// If we don't have any data buffered, go read the next chunk of data. |
|
if (self.bufferOffset == self.bufferLimit) { |
NSInteger bytesRead; |
|
bytesRead = [self.fileStream read:self.buffer maxLength:kSendBufferSize]; |
|
if (bytesRead == -1) { |
[self stopSendWithStatus:@"File read error"]; |
} else if (bytesRead == 0) { |
[self stopSendWithStatus:nil]; |
} else { |
self.bufferOffset = 0; |
self.bufferLimit = bytesRead; |
} |
} |
|
// If we're not out of data completely, send the next chunk. |
|
if (self.bufferOffset != self.bufferLimit) { |
NSInteger bytesWritten; |
|
bytesWritten = [self.networkStream write:&self.buffer[self.bufferOffset] maxLength:self.bufferLimit - self.bufferOffset]; |
assert(bytesWritten != 0); |
if (bytesWritten == -1) { |
[self stopSendWithStatus:@"Network write error"]; |
} else { |
self.bufferOffset += bytesWritten; |
} |
} |
} break; |
case NSStreamEventErrorOccurred: { |
[self stopSendWithStatus:@"Stream open error"]; |
} break; |
case NSStreamEventEndEncountered: { |
// ignore |
} break; |
default: { |
assert(NO); |
} break; |
} |
} |
|
#pragma mark * Actions |
|
- (IBAction)sendAction:(UIView *)sender |
{ |
assert( [sender isKindOfClass:[UIView class]] ); |
|
if ( ! self.isSending ) { |
NSString * filePath; |
|
// Use the tag on the button to determine which image to send. |
|
filePath = [[NetworkManager sharedInstance] pathForTestImage:sender.tag]; |
assert(filePath != nil); |
|
[self startSend:filePath]; |
} |
} |
|
- (IBAction)cancelAction:(id)sender |
{ |
#pragma unused(sender) |
[self stopSendWithStatus:@"Cancelled"]; |
} |
|
#pragma mark * View controller boilerplate |
|
- (void)viewDidLoad |
{ |
[super viewDidLoad]; |
assert(self.statusLabel != nil); |
assert(self.activityIndicator != nil); |
assert(self.cancelButton != nil); |
|
self.activityIndicator.hidden = YES; |
self.statusLabel.text = @"Tap a picture to start the send"; |
self.cancelButton.enabled = NO; |
} |
|
- (void)viewDidUnload |
{ |
[super viewDidUnload]; |
self.statusLabel = nil; |
self.activityIndicator = nil; |
self.cancelButton = nil; |
} |
|
- (void)dealloc |
{ |
[self stopSendWithStatus:@"Stopped"]; |
} |
|
@end |
