309 lines
10 KiB
Objective-C
309 lines
10 KiB
Objective-C
/*
|
|
* Copyright 2017 Google
|
|
*
|
|
* Licensed 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.
|
|
*/
|
|
|
|
// Targetted compilation is ONLY for testing. UIKit is weak-linked in actual release build.
|
|
|
|
#import <Foundation/Foundation.h>
|
|
|
|
#import <FirebaseCore/FIRLogger.h>
|
|
#import "FWebSocketConnection.h"
|
|
#import "FConstants.h"
|
|
#import "FIRDatabaseReference.h"
|
|
#import "FStringUtilities.h"
|
|
#import "FIRDatabase_Private.h"
|
|
|
|
#if TARGET_OS_IOS || TARGET_OS_TV
|
|
#import <UIKit/UIKit.h>
|
|
#endif
|
|
|
|
@interface FWebSocketConnection () {
|
|
NSMutableString* frame;
|
|
BOOL everConnected;
|
|
BOOL isClosed;
|
|
NSTimer* keepAlive;
|
|
}
|
|
|
|
- (void) shutdown;
|
|
- (void) onClosed;
|
|
- (void) closeIfNeverConnected;
|
|
|
|
@property (nonatomic, strong) FSRWebSocket* webSocket;
|
|
@property (nonatomic, strong) NSNumber* connectionId;
|
|
@property (nonatomic, readwrite) int totalFrames;
|
|
@property (nonatomic, readonly) BOOL buffering;
|
|
@property (nonatomic, readonly) NSString* userAgent;
|
|
@property (nonatomic) dispatch_queue_t dispatchQueue;
|
|
|
|
- (void)nop:(NSTimer *)timer;
|
|
|
|
@end
|
|
|
|
@implementation FWebSocketConnection
|
|
|
|
@synthesize delegate;
|
|
@synthesize webSocket;
|
|
@synthesize connectionId;
|
|
|
|
- (id)initWith:(FRepoInfo *)repoInfo andQueue:(dispatch_queue_t)queue lastSessionID:(NSString *)lastSessionID {
|
|
self = [super init];
|
|
if (self) {
|
|
everConnected = NO;
|
|
isClosed = NO;
|
|
self.connectionId = [FUtilities LUIDGenerator];
|
|
self.totalFrames = 0;
|
|
self.dispatchQueue = queue;
|
|
frame = nil;
|
|
|
|
NSString* connectionUrl = [repoInfo connectionURLWithLastSessionID:lastSessionID];
|
|
NSString* ua = [self userAgent];
|
|
FFLog(@"I-RDB083001", @"(wsc:%@) Connecting to: %@ as %@", self.connectionId, connectionUrl, ua);
|
|
|
|
NSURLRequest* req = [[NSURLRequest alloc] initWithURL:[[NSURL alloc] initWithString:connectionUrl]];
|
|
self.webSocket = [[FSRWebSocket alloc] initWithURLRequest:req queue:queue andUserAgent:ua];
|
|
[self.webSocket setDelegateDispatchQueue:queue];
|
|
self.webSocket.delegate = self;
|
|
}
|
|
return self;
|
|
}
|
|
|
|
- (NSString *) userAgent {
|
|
NSString* systemVersion;
|
|
NSString* deviceName;
|
|
BOOL hasUiDeviceClass = NO;
|
|
|
|
// Targetted compilation is ONLY for testing. UIKit is weak-linked in actual release build.
|
|
#if TARGET_OS_IOS || TARGET_OS_TV
|
|
Class uiDeviceClass = NSClassFromString(@"UIDevice");
|
|
if (uiDeviceClass) {
|
|
systemVersion = [uiDeviceClass currentDevice].systemVersion;
|
|
deviceName = [uiDeviceClass currentDevice].model;
|
|
hasUiDeviceClass = YES;
|
|
}
|
|
#endif
|
|
|
|
if (!hasUiDeviceClass) {
|
|
NSDictionary *systemVersionDictionary = [NSDictionary dictionaryWithContentsOfFile:@"/System/Library/CoreServices/SystemVersion.plist"];
|
|
systemVersion = [systemVersionDictionary objectForKey:@"ProductVersion"];
|
|
deviceName = [systemVersionDictionary objectForKey:@"ProductName"];
|
|
}
|
|
|
|
NSString* bundleIdentifier = [[NSBundle mainBundle] bundleIdentifier];
|
|
|
|
// Sanitize '/'s in deviceName and bundleIdentifier for stats
|
|
deviceName = [FStringUtilities sanitizedForUserAgent:deviceName];
|
|
bundleIdentifier = [FStringUtilities sanitizedForUserAgent:bundleIdentifier];
|
|
|
|
// Firebase/5/<semver>_<build date>_<git hash>/<os version>/{device model / os (Mac OS X, iPhone, etc.}_<bundle id>
|
|
NSString* ua = [NSString stringWithFormat:@"Firebase/%@/%@/%@/%@_%@", kWebsocketProtocolVersion, [FIRDatabase buildVersion], systemVersion, deviceName, bundleIdentifier];
|
|
return ua;
|
|
}
|
|
|
|
- (BOOL) buffering {
|
|
return frame != nil;
|
|
}
|
|
|
|
#pragma mark -
|
|
#pragma mark Public FWebSocketConnection methods
|
|
|
|
- (void) open {
|
|
FFLog(@"I-RDB083002", @"(wsc:%@) FWebSocketConnection open.", self.connectionId);
|
|
assert(delegate);
|
|
everConnected = NO;
|
|
// TODO Assert url
|
|
[self.webSocket open];
|
|
dispatch_time_t when = dispatch_time(DISPATCH_TIME_NOW, kWebsocketConnectTimeout * NSEC_PER_SEC);
|
|
dispatch_after(when, self.dispatchQueue, ^{
|
|
[self closeIfNeverConnected];
|
|
});
|
|
}
|
|
|
|
- (void) close {
|
|
FFLog(@"I-RDB083003", @"(wsc:%@) FWebSocketConnection is being closed.", self.connectionId);
|
|
isClosed = YES;
|
|
[self.webSocket close];
|
|
}
|
|
|
|
- (void) start {
|
|
// Start is a no-op for websockets.
|
|
}
|
|
|
|
- (void) send:(NSDictionary *)dictionary {
|
|
|
|
[self resetKeepAlive];
|
|
|
|
NSData* jsonData = [NSJSONSerialization dataWithJSONObject:dictionary
|
|
options:kNilOptions error:nil];
|
|
|
|
NSString* data = [[NSString alloc] initWithData:jsonData
|
|
encoding:NSUTF8StringEncoding];
|
|
|
|
NSArray* dataSegs = [FUtilities splitString:data intoMaxSize:kWebsocketMaxFrameSize];
|
|
|
|
// First send the header so the server knows how many segments are forthcoming
|
|
if (dataSegs.count > 1) {
|
|
[self.webSocket send:[NSString stringWithFormat:@"%u", (unsigned int)dataSegs.count]];
|
|
}
|
|
|
|
// Then, actually send the segments.
|
|
for(NSString * segment in dataSegs) {
|
|
[self.webSocket send:segment];
|
|
}
|
|
}
|
|
|
|
- (void) nop:(NSTimer *)timer {
|
|
if (!isClosed) {
|
|
FFLog(@"I-RDB083004", @"(wsc:%@) nop", self.connectionId);
|
|
[self.webSocket send:@"0"];
|
|
}
|
|
else {
|
|
FFLog(@"I-RDB083005", @"(wsc:%@) No more websocket; invalidating nop timer.", self.connectionId);
|
|
[timer invalidate];
|
|
}
|
|
}
|
|
|
|
- (void) handleNewFrameCount:(int) numFrames {
|
|
self.totalFrames = numFrames;
|
|
frame = [[NSMutableString alloc] initWithString:@""];
|
|
FFLog(@"I-RDB083006", @"(wsc:%@) handleNewFrameCount: %d", self.connectionId, self.totalFrames);
|
|
}
|
|
|
|
- (NSString *) extractFrameCount:(NSString *) message {
|
|
if ([message length] <= 4) {
|
|
int frameCount = [message intValue];
|
|
if (frameCount > 0) {
|
|
[self handleNewFrameCount:frameCount];
|
|
return nil;
|
|
}
|
|
}
|
|
[self handleNewFrameCount:1];
|
|
return message;
|
|
}
|
|
|
|
- (void) appendFrame:(NSString *) message {
|
|
[frame appendString:message];
|
|
self.totalFrames = self.totalFrames - 1;
|
|
|
|
if (self.totalFrames == 0) {
|
|
// Call delegate and pass an immutable version of the frame
|
|
NSDictionary* json = [NSJSONSerialization JSONObjectWithData:[frame dataUsingEncoding:NSUTF8StringEncoding]
|
|
options:kNilOptions
|
|
error:nil];
|
|
frame = nil;
|
|
FFLog(@"I-RDB083007", @"(wsc:%@) handleIncomingFrame sending complete frame: %d", self.connectionId, self.totalFrames);
|
|
|
|
@autoreleasepool {
|
|
[self.delegate onMessage:self withMessage:json];
|
|
}
|
|
}
|
|
}
|
|
|
|
- (void) handleIncomingFrame:(NSString *) message {
|
|
[self resetKeepAlive];
|
|
if (self.buffering) {
|
|
[self appendFrame:message];
|
|
} else {
|
|
NSString *remaining = [self extractFrameCount:message];
|
|
if (remaining) {
|
|
[self appendFrame:remaining];
|
|
}
|
|
}
|
|
}
|
|
|
|
#pragma mark -
|
|
#pragma mark SRWebSocketDelegate implementation
|
|
- (void)webSocket:(FSRWebSocket *)webSocket didReceiveMessage:(id)message
|
|
{
|
|
[self handleIncomingFrame:message];
|
|
}
|
|
|
|
- (void)webSocketDidOpen:(FSRWebSocket *)webSocket
|
|
{
|
|
FFLog(@"I-RDB083008", @"(wsc:%@) webSocketDidOpen", self.connectionId);
|
|
|
|
everConnected = YES;
|
|
|
|
dispatch_async(dispatch_get_main_queue(), ^{
|
|
self->keepAlive = [NSTimer scheduledTimerWithTimeInterval:kWebsocketKeepaliveInterval
|
|
target:self
|
|
selector:@selector(nop:)
|
|
userInfo:nil
|
|
repeats:YES];
|
|
FFLog(@"I-RDB083009", @"(wsc:%@) nop timer kicked off", self.connectionId);
|
|
});
|
|
}
|
|
|
|
- (void)webSocket:(FSRWebSocket *)webSocket didFailWithError:(NSError *)error
|
|
{
|
|
FFLog(@"I-RDB083010", @"(wsc:%@) didFailWithError didFailWithError: %@", self.connectionId, [error description]);
|
|
[self onClosed];
|
|
}
|
|
|
|
- (void)webSocket:(FSRWebSocket *)webSocket didCloseWithCode:(NSInteger)code reason:(NSString *)reason wasClean:(BOOL)wasClean
|
|
{
|
|
FFLog(@"I-RDB083011", @"(wsc:%@) didCloseWithCode: %ld %@", self.connectionId, (long)code, reason);
|
|
[self onClosed];
|
|
}
|
|
|
|
#pragma mark -
|
|
#pragma mark Private methods
|
|
|
|
/**
|
|
* Note that the close / onClosed / shutdown cycle here is a little different from the javascript client.
|
|
* In order to properly handle deallocation, no close-related action is taken at a higher level until we
|
|
* have received notification from the websocket itself that it is closed. Otherwise, we end up deallocating
|
|
* this class and the FConnection class before the websocket has a change to call some of its delegate methods.
|
|
* So, since close is the external close handler, we just set a flag saying not to call our own delegate method
|
|
* and close the websocket. That will trigger a callback into this class that can then do things like clean up
|
|
* the keepalive timer.
|
|
*/
|
|
|
|
- (void) closeIfNeverConnected {
|
|
if (!everConnected) {
|
|
FFLog(@"I-RDB083012", @"(wsc:%@) Websocket timed out on connect", self.connectionId);
|
|
[self.webSocket close];
|
|
}
|
|
}
|
|
|
|
- (void) shutdown {
|
|
isClosed = YES;
|
|
|
|
// Call delegate methods
|
|
[self.delegate onDisconnect:self wasEverConnected:everConnected];
|
|
|
|
}
|
|
|
|
- (void) onClosed {
|
|
if (!isClosed) {
|
|
FFLog(@"I-RDB083013", @"Websocket is closing itself");
|
|
[self shutdown];
|
|
}
|
|
self.webSocket = nil;
|
|
if (keepAlive.isValid) {
|
|
[keepAlive invalidate];
|
|
}
|
|
}
|
|
|
|
- (void) resetKeepAlive {
|
|
NSDate* newTime = [NSDate dateWithTimeIntervalSinceNow:kWebsocketKeepaliveInterval];
|
|
// Calling setFireDate is actually kinda' expensive, so wait at least 5 seconds before updating it.
|
|
if ([newTime timeIntervalSinceDate:keepAlive.fireDate] > 5) {
|
|
FFLog(@"I-RDB083014", @"(wsc:%@) resetting keepalive, to %@ ; old: %@", self.connectionId, newTime, [keepAlive fireDate]);
|
|
[keepAlive setFireDate:newTime];
|
|
}
|
|
}
|
|
|
|
@end
|