1510 lines
60 KiB
Objective-C
1510 lines
60 KiB
Objective-C
//
|
|
// Copyright (c) 2017 Open Whisper Systems. All rights reserved.
|
|
//
|
|
|
|
#import "OWSProfileManager.h"
|
|
#import "Environment.h"
|
|
#import "NSString+OWS.h"
|
|
#import "Signal-Swift.h"
|
|
#import <SignalServiceKit/Cryptography.h>
|
|
#import <SignalServiceKit/NSData+Image.h>
|
|
#import <SignalServiceKit/NSData+hexString.h>
|
|
#import <SignalServiceKit/NSDate+OWS.h>
|
|
#import <SignalServiceKit/NSNotificationCenter+OWS.h>
|
|
#import <SignalServiceKit/OWSFileSystem.h>
|
|
#import <SignalServiceKit/OWSMessageSender.h>
|
|
#import <SignalServiceKit/OWSRequestBuilder.h>
|
|
#import <SignalServiceKit/SecurityUtils.h>
|
|
#import <SignalServiceKit/TSAccountManager.h>
|
|
#import <SignalServiceKit/TSGroupThread.h>
|
|
#import <SignalServiceKit/TSProfileAvatarUploadFormRequest.h>
|
|
#import <SignalServiceKit/TSStorageManager.h>
|
|
#import <SignalServiceKit/TSThread.h>
|
|
#import <SignalServiceKit/TSYapDatabaseObject.h>
|
|
#import <SignalServiceKit/TextSecureKitEnv.h>
|
|
|
|
NS_ASSUME_NONNULL_BEGIN
|
|
|
|
// UserProfile properties may be read from any thread, but should
|
|
// only be mutated when synchronized on the profile manager.
|
|
@interface UserProfile : TSYapDatabaseObject
|
|
|
|
@property (atomic, readonly) NSString *recipientId;
|
|
@property (atomic, nullable) OWSAES256Key *profileKey;
|
|
@property (atomic, nullable) NSString *profileName;
|
|
@property (atomic, nullable) NSString *avatarUrlPath;
|
|
// This filename is relative to OWSProfileManager.profileAvatarsDirPath.
|
|
@property (atomic, nullable) NSString *avatarFileName;
|
|
|
|
// This should reflect when either:
|
|
//
|
|
// * The last successful update finished.
|
|
// * The current in-flight update began.
|
|
@property (atomic, nullable) NSDate *lastUpdateDate;
|
|
|
|
- (instancetype)init NS_UNAVAILABLE;
|
|
|
|
@end
|
|
|
|
#pragma mark -
|
|
|
|
@implementation UserProfile
|
|
|
|
@synthesize profileName = _profileName;
|
|
|
|
- (instancetype)initWithRecipientId:(NSString *)recipientId
|
|
{
|
|
self = [super initWithUniqueId:recipientId];
|
|
|
|
if (!self) {
|
|
return self;
|
|
}
|
|
|
|
OWSAssert(recipientId.length > 0);
|
|
_recipientId = recipientId;
|
|
|
|
return self;
|
|
}
|
|
|
|
- (nullable NSString *)profileName
|
|
{
|
|
@synchronized(self)
|
|
{
|
|
return _profileName;
|
|
}
|
|
}
|
|
|
|
- (void)setProfileName:(nullable NSString *)profileName
|
|
{
|
|
@synchronized(self)
|
|
{
|
|
_profileName = [profileName ows_stripped];
|
|
}
|
|
}
|
|
|
|
@end
|
|
|
|
#pragma mark -
|
|
|
|
NSString *const kLocalProfileUniqueId = @"kLocalProfileUniqueId";
|
|
|
|
NSString *const kNSNotificationName_LocalProfileDidChange = @"kNSNotificationName_LocalProfileDidChange";
|
|
NSString *const kNSNotificationName_OtherUsersProfileWillChange = @"kNSNotificationName_OtherUsersProfileWillChange";
|
|
NSString *const kNSNotificationName_OtherUsersProfileDidChange = @"kNSNotificationName_OtherUsersProfileDidChange";
|
|
NSString *const kNSNotificationName_ProfileWhitelistDidChange = @"kNSNotificationName_ProfileWhitelistDidChange";
|
|
NSString *const kNSNotificationKey_ProfileRecipientId = @"kNSNotificationKey_ProfileRecipientId";
|
|
NSString *const kNSNotificationKey_ProfileGroupId = @"kNSNotificationKey_ProfileGroupId";
|
|
|
|
NSString *const kOWSProfileManager_UserWhitelistCollection = @"kOWSProfileManager_UserWhitelistCollection";
|
|
NSString *const kOWSProfileManager_GroupWhitelistCollection = @"kOWSProfileManager_GroupWhitelistCollection";
|
|
|
|
// The max bytes for a user's profile name, encoded in UTF8.
|
|
// Before encrypting and submitting we NULL pad the name data to this length.
|
|
const NSUInteger kOWSProfileManager_NameDataLength = 26;
|
|
const NSUInteger kOWSProfileManager_MaxAvatarDiameter = 640;
|
|
|
|
@interface OWSProfileManager ()
|
|
|
|
@property (nonatomic, readonly) OWSMessageSender *messageSender;
|
|
@property (nonatomic, readonly) YapDatabaseConnection *dbConnection;
|
|
@property (nonatomic, readonly) TSNetworkManager *networkManager;
|
|
@property (nonatomic, readonly) OWSIdentityManager *identityManager;
|
|
|
|
// This property can be accessed on any thread, while synchronized on self.
|
|
@property (nonatomic, readonly) UserProfile *localUserProfile;
|
|
// This property can be accessed on any thread, while synchronized on self.
|
|
@property (atomic, nullable) UIImage *localCachedAvatarImage;
|
|
|
|
// These caches are lazy-populated. The single point of truth is the database.
|
|
//
|
|
// This property can be accessed on any thread, while synchronized on self.
|
|
@property (atomic, readonly) NSMutableDictionary<NSString *, NSNumber *> *userProfileWhitelistCache;
|
|
// This property can be accessed on any thread, while synchronized on self.
|
|
@property (atomic, readonly) NSMutableDictionary<NSString *, NSNumber *> *groupProfileWhitelistCache;
|
|
|
|
// This property can be accessed on any thread, while synchronized on self.
|
|
@property (atomic, readonly) NSCache<NSString *, UIImage *> *otherUsersProfileAvatarImageCache;
|
|
// This property can be accessed on any thread, while synchronized on self.
|
|
@property (atomic, readonly) NSMutableSet<NSString *> *currentAvatarDownloads;
|
|
|
|
@end
|
|
|
|
#pragma mark -
|
|
|
|
// Access to most state should happen while synchronized on the profile manager.
|
|
// Writes should happen off the main thread, wherever possible.
|
|
@implementation OWSProfileManager
|
|
|
|
@synthesize localUserProfile = _localUserProfile;
|
|
|
|
+ (instancetype)sharedManager
|
|
{
|
|
static OWSProfileManager *sharedMyManager = nil;
|
|
static dispatch_once_t onceToken;
|
|
dispatch_once(&onceToken, ^{
|
|
sharedMyManager = [[self alloc] initDefault];
|
|
});
|
|
return sharedMyManager;
|
|
}
|
|
|
|
- (instancetype)initDefault
|
|
{
|
|
TSStorageManager *storageManager = [TSStorageManager sharedManager];
|
|
OWSMessageSender *messageSender = [Environment getCurrent].messageSender;
|
|
TSNetworkManager *networkManager = [Environment getCurrent].networkManager;
|
|
|
|
return [self initWithStorageManager:storageManager messageSender:messageSender networkManager:networkManager];
|
|
}
|
|
|
|
- (instancetype)initWithStorageManager:(TSStorageManager *)storageManager
|
|
messageSender:(OWSMessageSender *)messageSender
|
|
networkManager:(TSNetworkManager *)networkManager
|
|
{
|
|
self = [super init];
|
|
|
|
if (!self) {
|
|
return self;
|
|
}
|
|
|
|
OWSAssert([NSThread isMainThread]);
|
|
OWSAssert(storageManager);
|
|
OWSAssert(messageSender);
|
|
OWSAssert(messageSender);
|
|
|
|
_messageSender = messageSender;
|
|
_dbConnection = storageManager.newDatabaseConnection;
|
|
_networkManager = networkManager;
|
|
|
|
_userProfileWhitelistCache = [NSMutableDictionary new];
|
|
_groupProfileWhitelistCache = [NSMutableDictionary new];
|
|
_otherUsersProfileAvatarImageCache = [NSCache new];
|
|
_currentAvatarDownloads = [NSMutableSet new];
|
|
|
|
OWSSingletonAssert();
|
|
|
|
return self;
|
|
}
|
|
|
|
- (void)dealloc
|
|
{
|
|
[[NSNotificationCenter defaultCenter] removeObserver:self];
|
|
}
|
|
|
|
- (void)observeNotifications
|
|
{
|
|
[[NSNotificationCenter defaultCenter] addObserver:self
|
|
selector:@selector(applicationDidBecomeActive:)
|
|
name:UIApplicationDidBecomeActiveNotification
|
|
object:nil];
|
|
}
|
|
|
|
- (AFHTTPSessionManager *)avatarHTTPManager
|
|
{
|
|
return [OWSSignalService sharedInstance].CDNSessionManager;
|
|
}
|
|
|
|
- (OWSIdentityManager *)identityManager
|
|
{
|
|
return [OWSIdentityManager sharedManager];
|
|
}
|
|
|
|
#pragma mark - User Profile Accessor
|
|
|
|
// This method can be safely called from any thread.
|
|
- (UserProfile *)getOrBuildUserProfileForRecipientId:(NSString *)recipientId
|
|
{
|
|
OWSAssert(recipientId.length > 0);
|
|
|
|
__block UserProfile *instance;
|
|
// Make sure to read on the local db connection for consistency.
|
|
[self.dbConnection readWithBlock:^(YapDatabaseReadTransaction *transaction) {
|
|
instance = [UserProfile fetchObjectWithUniqueID:recipientId transaction:transaction];
|
|
}];
|
|
|
|
if (!instance) {
|
|
instance = [[UserProfile alloc] initWithRecipientId:recipientId];
|
|
}
|
|
|
|
OWSAssert(instance);
|
|
|
|
return instance;
|
|
}
|
|
|
|
- (void)saveUserProfile:(UserProfile *)userProfile
|
|
{
|
|
OWSAssert(userProfile);
|
|
|
|
// Make a copy to use inside the transaction.
|
|
// To avoid deadlock, we want to avoid creating a new transaction while sync'd on self.
|
|
UserProfile *userProfileCopy;
|
|
@synchronized(self)
|
|
{
|
|
userProfileCopy = [userProfile copy];
|
|
// Other threads may modify this profile's properties
|
|
OWSAssert([userProfile isEqual:userProfileCopy]);
|
|
}
|
|
|
|
dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
|
|
// Make sure to save on the local db connection for consistency.
|
|
[self.dbConnection readWriteWithBlock:^(YapDatabaseReadWriteTransaction *transaction) {
|
|
[userProfileCopy saveWithTransaction:transaction];
|
|
}];
|
|
|
|
BOOL isLocalUserProfile = userProfile == self.localUserProfile;
|
|
|
|
dispatch_async(dispatch_get_main_queue(), ^{
|
|
if (isLocalUserProfile) {
|
|
// We populate an initial (empty) profile on launch of a new install, but until
|
|
// we have a registered account, syncing will fail (and there could not be any
|
|
// linked device to sync to at this point anyway).
|
|
if ([TSAccountManager isRegistered]) {
|
|
[MultiDeviceProfileKeyUpdateJob runWithProfileKey:userProfile.profileKey
|
|
identityManager:self.identityManager
|
|
messageSender:self.messageSender
|
|
profileManager:self];
|
|
}
|
|
|
|
[[NSNotificationCenter defaultCenter] postNotificationNameAsync:kNSNotificationName_LocalProfileDidChange
|
|
object:nil
|
|
userInfo:nil];
|
|
} else {
|
|
[[NSNotificationCenter defaultCenter]
|
|
postNotificationNameAsync:kNSNotificationName_OtherUsersProfileWillChange
|
|
object:nil
|
|
userInfo:@{
|
|
kNSNotificationKey_ProfileRecipientId : userProfile.recipientId,
|
|
}];
|
|
[[NSNotificationCenter defaultCenter]
|
|
postNotificationNameAsync:kNSNotificationName_OtherUsersProfileDidChange
|
|
object:nil
|
|
userInfo:@{
|
|
kNSNotificationKey_ProfileRecipientId : userProfile.recipientId,
|
|
}];
|
|
}
|
|
});
|
|
});
|
|
}
|
|
|
|
- (void)ensureLocalProfileCached
|
|
{
|
|
// Since localUserProfile can create a transaction, we want to make sure it's not called for the first
|
|
// time unexpectedly (e.g. in a nested transaction.)
|
|
__unused UserProfile *profile = [self localUserProfile];
|
|
}
|
|
|
|
#pragma mark - Local Profile
|
|
|
|
- (UserProfile *)localUserProfile
|
|
{
|
|
@synchronized(self)
|
|
{
|
|
if (_localUserProfile == nil) {
|
|
// Make sure to read on the local db connection for consistency.
|
|
[self.dbConnection readWithBlock:^(YapDatabaseReadTransaction *transaction) {
|
|
_localUserProfile = [UserProfile fetchObjectWithUniqueID:kLocalProfileUniqueId transaction:transaction];
|
|
}];
|
|
|
|
if (_localUserProfile == nil) {
|
|
DDLogInfo(@"%@ Building local profile.", self.logTag);
|
|
_localUserProfile = [[UserProfile alloc] initWithRecipientId:kLocalProfileUniqueId];
|
|
_localUserProfile.profileKey = [OWSAES256Key generateRandomKey];
|
|
|
|
dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
|
|
[self saveUserProfile:_localUserProfile];
|
|
});
|
|
}
|
|
}
|
|
|
|
return _localUserProfile;
|
|
}
|
|
}
|
|
|
|
- (OWSAES256Key *)localProfileKey
|
|
{
|
|
@synchronized(self)
|
|
{
|
|
OWSAssert(self.localUserProfile.profileKey.keyData.length == kAES256_KeyByteLength);
|
|
|
|
return self.localUserProfile.profileKey;
|
|
}
|
|
}
|
|
|
|
- (BOOL)hasLocalProfile
|
|
{
|
|
return (self.localProfileName.length > 0 || self.localProfileAvatarImage != nil);
|
|
}
|
|
|
|
- (nullable NSString *)localProfileName
|
|
{
|
|
@synchronized(self)
|
|
{
|
|
return self.localUserProfile.profileName;
|
|
}
|
|
}
|
|
|
|
- (nullable UIImage *)localProfileAvatarImage
|
|
{
|
|
@synchronized(self)
|
|
{
|
|
if (!self.localCachedAvatarImage) {
|
|
if (self.localUserProfile.avatarFileName) {
|
|
self.localCachedAvatarImage = [self loadProfileAvatarWithFilename:self.localUserProfile.avatarFileName];
|
|
}
|
|
}
|
|
|
|
return self.localCachedAvatarImage;
|
|
}
|
|
}
|
|
|
|
- (void)updateLocalProfileName:(nullable NSString *)profileName
|
|
avatarImage:(nullable UIImage *)avatarImage
|
|
success:(void (^)(void))successBlockParameter
|
|
failure:(void (^)(void))failureBlockParameter
|
|
{
|
|
OWSAssert(successBlockParameter);
|
|
OWSAssert(failureBlockParameter);
|
|
|
|
dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
|
|
@synchronized(self)
|
|
{
|
|
// Ensure that the success and failure blocks are called on the main thread.
|
|
void (^failureBlock)(void) = ^{
|
|
DDLogError(@"%@ Updating service with profile failed.", self.logTag);
|
|
|
|
dispatch_async(dispatch_get_main_queue(), ^{
|
|
failureBlockParameter();
|
|
});
|
|
};
|
|
void (^successBlock)(void) = ^{
|
|
DDLogInfo(@"%@ Successfully updated service with profile.", self.logTag);
|
|
|
|
dispatch_async(dispatch_get_main_queue(), ^{
|
|
successBlockParameter();
|
|
});
|
|
};
|
|
|
|
// The final steps are to:
|
|
//
|
|
// * Try to update the service.
|
|
// * Update client state on success.
|
|
void (^tryToUpdateService)(NSString *_Nullable, NSString *_Nullable)
|
|
= ^(NSString *_Nullable avatarUrlPath, NSString *_Nullable avatarFileName) {
|
|
[self updateServiceWithProfileName:profileName
|
|
success:^{
|
|
dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
|
|
@synchronized(self)
|
|
{
|
|
UserProfile *userProfile = self.localUserProfile;
|
|
OWSAssert(userProfile);
|
|
userProfile.profileName = profileName;
|
|
|
|
// TODO remote avatarUrlPath changes as result of fetching form -
|
|
// we should probably invalidate it at that point, and refresh again when
|
|
// uploading file completes.
|
|
userProfile.avatarUrlPath = avatarUrlPath;
|
|
userProfile.avatarFileName = avatarFileName;
|
|
|
|
[self saveUserProfile:userProfile];
|
|
|
|
self.localCachedAvatarImage = avatarImage;
|
|
|
|
successBlock();
|
|
}
|
|
});
|
|
}
|
|
failure:^{
|
|
failureBlock();
|
|
}];
|
|
};
|
|
|
|
UserProfile *userProfile = self.localUserProfile;
|
|
OWSAssert(userProfile);
|
|
|
|
if (avatarImage) {
|
|
// If we have a new avatar image, we must first:
|
|
//
|
|
// * Encode it to JPEG.
|
|
// * Write it to disk.
|
|
// * Encrypt it
|
|
// * Upload it to asset service
|
|
// * Send asset service info to Signal Service
|
|
if (self.localCachedAvatarImage == avatarImage) {
|
|
OWSAssert(userProfile.avatarUrlPath.length > 0);
|
|
OWSAssert(userProfile.avatarFileName.length > 0);
|
|
|
|
DDLogVerbose(@"%@ Updating local profile on service with unchanged avatar.", self.logTag);
|
|
// If the avatar hasn't changed, reuse the existing metadata.
|
|
tryToUpdateService(userProfile.avatarUrlPath, userProfile.avatarFileName);
|
|
} else {
|
|
DDLogVerbose(@"%@ Updating local profile on service with new avatar.", self.logTag);
|
|
[self writeAvatarToDisk:avatarImage
|
|
success:^(NSData *data, NSString *fileName) {
|
|
[self uploadAvatarToService:data
|
|
success:^(NSString *_Nullable avatarUrlPath) {
|
|
tryToUpdateService(avatarUrlPath, fileName);
|
|
}
|
|
failure:^{
|
|
failureBlock();
|
|
}];
|
|
}
|
|
failure:^{
|
|
failureBlock();
|
|
}];
|
|
}
|
|
} else if (userProfile.avatarUrlPath) {
|
|
DDLogVerbose(@"%@ Updating local profile on service with cleared avatar.", self.logTag);
|
|
[self uploadAvatarToService:nil
|
|
success:^(NSString *_Nullable avatarUrlPath) {
|
|
tryToUpdateService(nil, nil);
|
|
}
|
|
failure:^{
|
|
failureBlock();
|
|
}];
|
|
} else {
|
|
DDLogVerbose(@"%@ Updating local profile on service with no avatar.", self.logTag);
|
|
tryToUpdateService(nil, nil);
|
|
}
|
|
}
|
|
});
|
|
}
|
|
|
|
- (void)writeAvatarToDisk:(UIImage *)avatar
|
|
success:(void (^)(NSData *data, NSString *fileName))successBlock
|
|
failure:(void (^)(void))failureBlock
|
|
{
|
|
OWSAssert(avatar);
|
|
OWSAssert(successBlock);
|
|
OWSAssert(failureBlock);
|
|
|
|
dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
|
|
if (avatar) {
|
|
NSData *data = [self processedImageDataForRawAvatar:avatar];
|
|
OWSAssert(data);
|
|
if (data) {
|
|
NSString *fileName = [[NSUUID UUID].UUIDString stringByAppendingPathExtension:@"jpg"];
|
|
NSString *filePath = [self.profileAvatarsDirPath stringByAppendingPathComponent:fileName];
|
|
BOOL success = [data writeToFile:filePath atomically:YES];
|
|
OWSAssert(success);
|
|
if (success) {
|
|
successBlock(data, fileName);
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
failureBlock();
|
|
});
|
|
}
|
|
|
|
- (NSData *)processedImageDataForRawAvatar:(UIImage *)image
|
|
{
|
|
NSUInteger kMaxAvatarBytes = 5 * 1000 * 1000;
|
|
|
|
if (image.size.width != kOWSProfileManager_MaxAvatarDiameter
|
|
|| image.size.height != kOWSProfileManager_MaxAvatarDiameter) {
|
|
// To help ensure the user is being shown the same cropping of their avatar as
|
|
// everyone else will see, we want to be sure that the image was resized before this point.
|
|
OWSFail(@"Avatar image should have been resized before trying to upload");
|
|
image = [image resizedImageToFillPixelSize:CGSizeMake(kOWSProfileManager_MaxAvatarDiameter,
|
|
kOWSProfileManager_MaxAvatarDiameter)];
|
|
}
|
|
|
|
NSData *_Nullable data = UIImageJPEGRepresentation(image, 0.95f);
|
|
if (data.length > kMaxAvatarBytes) {
|
|
// Our avatar dimensions are so small that it's incredibly unlikely we wouldn't be able to fit our profile
|
|
// photo. e.g. generating pure noise at our resolution compresses to ~200k.
|
|
OWSFail(@"Suprised to find profile avatar was too large. Was it scaled properly? image: %@", image);
|
|
}
|
|
|
|
return data;
|
|
}
|
|
|
|
// If avatarData is nil, we are clearing the avatar.
|
|
- (void)uploadAvatarToService:(NSData *_Nullable)avatarData
|
|
success:(void (^)(NSString *_Nullable avatarUrlPath))successBlock
|
|
failure:(void (^)(void))failureBlock
|
|
{
|
|
OWSAssert(successBlock);
|
|
OWSAssert(failureBlock);
|
|
OWSAssert(avatarData == nil || avatarData.length > 0);
|
|
|
|
// We want to clear the local user's profile avatar as soon as
|
|
// we request the upload form, since that request clears our
|
|
// avatar on the service.
|
|
//
|
|
// TODO: Revisit this so that failed profile updates don't leave
|
|
// the profile avatar blank, etc.
|
|
void (^clearLocalAvatar)(void) = ^{
|
|
dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
|
|
@synchronized(self)
|
|
{
|
|
UserProfile *userProfile = self.localUserProfile;
|
|
OWSAssert(userProfile);
|
|
|
|
// TODO remote avatarUrlPath changes as result of fetching form -
|
|
// we should probably invalidate it at that point, and refresh again when
|
|
// uploading file completes.
|
|
userProfile.avatarUrlPath = nil;
|
|
userProfile.avatarFileName = nil;
|
|
|
|
[self saveUserProfile:userProfile];
|
|
|
|
self.localCachedAvatarImage = nil;
|
|
}
|
|
});
|
|
};
|
|
|
|
dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
|
|
// See: https://docs.aws.amazon.com/AmazonS3/latest/API/sigv4-UsingHTTPPOST.html
|
|
TSProfileAvatarUploadFormRequest *formRequest = [TSProfileAvatarUploadFormRequest new];
|
|
|
|
// TODO: Since this form request causes the server to reset my avatar URL, if the update fails
|
|
// at some point from here on out, we want the user to understand they probably no longer have
|
|
// a profile avatar on the server.
|
|
|
|
[self.networkManager makeRequest:formRequest
|
|
success:^(NSURLSessionDataTask *task, id formResponseObject) {
|
|
clearLocalAvatar();
|
|
|
|
if (avatarData == nil) {
|
|
DDLogDebug(@"%@ successfully cleared avatar", self.logTag);
|
|
successBlock(nil);
|
|
return;
|
|
}
|
|
|
|
if (![formResponseObject isKindOfClass:[NSDictionary class]]) {
|
|
OWSProdFail([OWSAnalyticsEvents profileManagerErrorAvatarUploadFormInvalidResponse]);
|
|
failureBlock();
|
|
return;
|
|
}
|
|
NSDictionary *responseMap = formResponseObject;
|
|
DDLogError(@"responseObject: %@", formResponseObject);
|
|
|
|
NSString *formAcl = responseMap[@"acl"];
|
|
if (![formAcl isKindOfClass:[NSString class]] || formAcl.length < 1) {
|
|
OWSProdFail([OWSAnalyticsEvents profileManagerErrorAvatarUploadFormInvalidAcl]);
|
|
failureBlock();
|
|
return;
|
|
}
|
|
NSString *formKey = responseMap[@"key"];
|
|
if (![formKey isKindOfClass:[NSString class]] || formKey.length < 1) {
|
|
OWSProdFail([OWSAnalyticsEvents profileManagerErrorAvatarUploadFormInvalidKey]);
|
|
failureBlock();
|
|
return;
|
|
}
|
|
NSString *formPolicy = responseMap[@"policy"];
|
|
if (![formPolicy isKindOfClass:[NSString class]] || formPolicy.length < 1) {
|
|
OWSProdFail([OWSAnalyticsEvents profileManagerErrorAvatarUploadFormInvalidPolicy]);
|
|
failureBlock();
|
|
return;
|
|
}
|
|
NSString *formAlgorithm = responseMap[@"algorithm"];
|
|
if (![formAlgorithm isKindOfClass:[NSString class]] || formAlgorithm.length < 1) {
|
|
OWSProdFail([OWSAnalyticsEvents profileManagerErrorAvatarUploadFormInvalidAlgorithm]);
|
|
failureBlock();
|
|
return;
|
|
}
|
|
NSString *formCredential = responseMap[@"credential"];
|
|
if (![formCredential isKindOfClass:[NSString class]] || formCredential.length < 1) {
|
|
OWSProdFail([OWSAnalyticsEvents profileManagerErrorAvatarUploadFormInvalidCredential]);
|
|
failureBlock();
|
|
return;
|
|
}
|
|
NSString *formDate = responseMap[@"date"];
|
|
if (![formDate isKindOfClass:[NSString class]] || formDate.length < 1) {
|
|
OWSProdFail([OWSAnalyticsEvents profileManagerErrorAvatarUploadFormInvalidDate]);
|
|
failureBlock();
|
|
return;
|
|
}
|
|
NSString *formSignature = responseMap[@"signature"];
|
|
if (![formSignature isKindOfClass:[NSString class]] || formSignature.length < 1) {
|
|
OWSProdFail([OWSAnalyticsEvents profileManagerErrorAvatarUploadFormInvalidSignature]);
|
|
failureBlock();
|
|
return;
|
|
}
|
|
|
|
[self.avatarHTTPManager POST:@""
|
|
parameters:nil
|
|
constructingBodyWithBlock:^(id<AFMultipartFormData> _Nonnull formData) {
|
|
NSData * (^formDataForString)(NSString *formString) = ^(NSString *formString) {
|
|
return [formString dataUsingEncoding:NSUTF8StringEncoding];
|
|
};
|
|
|
|
// We have to build up the form manually vs. simply passing in a paramaters dict
|
|
// because AWS is sensitive to the order of the form params (at least the "key"
|
|
// field must occur early on).
|
|
// For consistency, all fields are ordered here in a known working order.
|
|
[formData appendPartWithFormData:formDataForString(formKey) name:@"key"];
|
|
[formData appendPartWithFormData:formDataForString(formAcl) name:@"acl"];
|
|
[formData appendPartWithFormData:formDataForString(formAlgorithm) name:@"x-amz-algorithm"];
|
|
[formData appendPartWithFormData:formDataForString(formCredential) name:@"x-amz-credential"];
|
|
[formData appendPartWithFormData:formDataForString(formDate) name:@"x-amz-date"];
|
|
[formData appendPartWithFormData:formDataForString(formPolicy) name:@"policy"];
|
|
[formData appendPartWithFormData:formDataForString(formSignature) name:@"x-amz-signature"];
|
|
[formData appendPartWithFormData:formDataForString(OWSMimeTypeApplicationOctetStream)
|
|
name:@"Content-Type"];
|
|
NSData *encryptedAvatarData = [self encryptProfileData:avatarData];
|
|
OWSAssert(encryptedAvatarData.length > 0);
|
|
[formData appendPartWithFormData:encryptedAvatarData name:@"file"];
|
|
|
|
DDLogVerbose(@"%@ constructed body", self.logTag);
|
|
}
|
|
progress:^(NSProgress *_Nonnull uploadProgress) {
|
|
DDLogVerbose(
|
|
@"%@ avatar upload progress: %.2f%%", self.logTag, uploadProgress.fractionCompleted * 100);
|
|
}
|
|
success:^(NSURLSessionDataTask *_Nonnull uploadTask, id _Nullable responseObject) {
|
|
DDLogInfo(@"%@ successfully uploaded avatar with key: %@", self.logTag, formKey);
|
|
successBlock(formKey);
|
|
}
|
|
failure:^(NSURLSessionDataTask *_Nullable uploadTask, NSError *_Nonnull error) {
|
|
DDLogError(@"%@ uploading avatar failed with error: %@", self.logTag, error);
|
|
failureBlock();
|
|
}];
|
|
}
|
|
failure:^(NSURLSessionDataTask *task, NSError *error) {
|
|
// Only clear the local avatar if we have a response. Otherwise, we
|
|
// had a network failure and probably didn't reach the service.
|
|
if (task.response != nil) {
|
|
clearLocalAvatar();
|
|
}
|
|
|
|
DDLogError(@"%@ Failed to get profile avatar upload form: %@", self.logTag, error);
|
|
failureBlock();
|
|
}];
|
|
});
|
|
}
|
|
|
|
- (void)updateServiceWithProfileName:(nullable NSString *)localProfileName
|
|
success:(void (^)(void))successBlock
|
|
failure:(void (^)(void))failureBlock
|
|
{
|
|
OWSAssert(successBlock);
|
|
OWSAssert(failureBlock);
|
|
|
|
dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
|
|
NSData *_Nullable encryptedPaddedName = [self encryptProfileNameWithUnpaddedName:localProfileName];
|
|
|
|
TSRequest *request = [OWSRequestBuilder profileNameSetRequestWithEncryptedPaddedName:encryptedPaddedName];
|
|
[self.networkManager makeRequest:request
|
|
success:^(NSURLSessionDataTask *task, id responseObject) {
|
|
successBlock();
|
|
}
|
|
failure:^(NSURLSessionDataTask *task, NSError *error) {
|
|
DDLogError(@"%@ Failed to update profile with error: %@", self.logTag, error);
|
|
failureBlock();
|
|
}];
|
|
});
|
|
}
|
|
|
|
- (void)fetchLocalUsersProfile
|
|
{
|
|
OWSAssert([NSThread isMainThread]);
|
|
|
|
NSString *_Nullable localNumber = [TSAccountManager sharedInstance].localNumber;
|
|
if (!localNumber) {
|
|
return;
|
|
}
|
|
[ProfileFetcherJob runWithRecipientId:localNumber networkManager:self.networkManager ignoreThrottling:YES];
|
|
}
|
|
|
|
#pragma mark - Profile Whitelist
|
|
|
|
- (void)clearProfileWhitelist
|
|
{
|
|
DDLogWarn(@"%@ Clearing the profile whitelist.", self.logTag);
|
|
|
|
dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
|
|
@synchronized(self)
|
|
{
|
|
[self.userProfileWhitelistCache removeAllObjects];
|
|
[self.groupProfileWhitelistCache removeAllObjects];
|
|
|
|
[self.dbConnection purgeCollection:kOWSProfileManager_UserWhitelistCollection];
|
|
[self.dbConnection purgeCollection:kOWSProfileManager_GroupWhitelistCollection];
|
|
OWSAssert(0 == [self.dbConnection numberOfKeysInCollection:kOWSProfileManager_UserWhitelistCollection]);
|
|
OWSAssert(0 == [self.dbConnection numberOfKeysInCollection:kOWSProfileManager_GroupWhitelistCollection]);
|
|
}
|
|
});
|
|
}
|
|
|
|
- (void)logProfileWhitelist
|
|
{
|
|
dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
|
|
@synchronized(self)
|
|
{
|
|
DDLogError(@"userProfileWhitelistCache: %zd", self.userProfileWhitelistCache.count);
|
|
DDLogError(@"groupProfileWhitelistCache: %zd", self.groupProfileWhitelistCache.count);
|
|
DDLogError(@"kOWSProfileManager_UserWhitelistCollection: %zd",
|
|
[self.dbConnection numberOfKeysInCollection:kOWSProfileManager_UserWhitelistCollection]);
|
|
[self.dbConnection readWithBlock:^(YapDatabaseReadTransaction *transaction) {
|
|
[transaction enumerateKeysInCollection:kOWSProfileManager_UserWhitelistCollection
|
|
usingBlock:^(NSString *_Nonnull key, BOOL *_Nonnull stop) {
|
|
DDLogError(@"\t profile whitelist user: %@", key);
|
|
}];
|
|
}];
|
|
DDLogError(@"kOWSProfileManager_GroupWhitelistCollection: %zd",
|
|
[self.dbConnection numberOfKeysInCollection:kOWSProfileManager_GroupWhitelistCollection]);
|
|
[self.dbConnection readWithBlock:^(YapDatabaseReadTransaction *transaction) {
|
|
[transaction enumerateKeysInCollection:kOWSProfileManager_GroupWhitelistCollection
|
|
usingBlock:^(NSString *_Nonnull key, BOOL *_Nonnull stop) {
|
|
DDLogError(@"\t profile whitelist group: %@", key);
|
|
}];
|
|
}];
|
|
}
|
|
});
|
|
}
|
|
|
|
- (void)regenerateLocalProfile
|
|
{
|
|
dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
|
|
@synchronized(self)
|
|
{
|
|
_localUserProfile = nil;
|
|
DDLogWarn(@"%@ Removing local user profile", self.logTag);
|
|
[self.dbConnection readWriteWithBlock:^(YapDatabaseReadWriteTransaction *_Nonnull transaction) {
|
|
[transaction removeObjectForKey:kLocalProfileUniqueId inCollection:[UserProfile collection]];
|
|
}];
|
|
|
|
// rebuild localUserProfile
|
|
OWSAssert(self.localUserProfile);
|
|
}
|
|
});
|
|
}
|
|
|
|
- (void)addUserToProfileWhitelist:(NSString *)recipientId
|
|
{
|
|
OWSAssert(recipientId.length > 0);
|
|
|
|
[self addUsersToProfileWhitelist:@[ recipientId ]];
|
|
}
|
|
|
|
- (void)addUsersToProfileWhitelist:(NSArray<NSString *> *)recipientIds
|
|
{
|
|
OWSAssert(recipientIds);
|
|
|
|
dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
|
|
NSMutableArray<NSString *> *newRecipientIds = [NSMutableArray new];
|
|
|
|
@synchronized(self)
|
|
{
|
|
for (NSString *recipientId in recipientIds) {
|
|
if (![self isUserInProfileWhitelist:recipientId]) {
|
|
[newRecipientIds addObject:recipientId];
|
|
}
|
|
}
|
|
|
|
if (newRecipientIds.count < 1) {
|
|
return;
|
|
}
|
|
|
|
for (NSString *recipientId in recipientIds) {
|
|
self.userProfileWhitelistCache[recipientId] = @(YES);
|
|
}
|
|
}
|
|
|
|
[self.dbConnection readWriteWithBlock:^(YapDatabaseReadWriteTransaction *transaction) {
|
|
for (NSString *recipientId in recipientIds) {
|
|
[transaction setObject:@(YES)
|
|
forKey:recipientId
|
|
inCollection:kOWSProfileManager_UserWhitelistCollection];
|
|
}
|
|
}];
|
|
|
|
for (NSString *recipientId in newRecipientIds) {
|
|
[[NSNotificationCenter defaultCenter]
|
|
postNotificationNameAsync:kNSNotificationName_ProfileWhitelistDidChange
|
|
object:nil
|
|
userInfo:@{
|
|
kNSNotificationKey_ProfileRecipientId : recipientId,
|
|
}];
|
|
}
|
|
});
|
|
}
|
|
|
|
- (BOOL)isUserInProfileWhitelist:(NSString *)recipientId
|
|
{
|
|
OWSAssert(recipientId.length > 0);
|
|
|
|
@synchronized(self)
|
|
{
|
|
NSNumber *_Nullable value = self.userProfileWhitelistCache[recipientId];
|
|
if (value) {
|
|
return [value boolValue];
|
|
}
|
|
|
|
value =
|
|
@([self.dbConnection hasObjectForKey:recipientId inCollection:kOWSProfileManager_UserWhitelistCollection]);
|
|
self.userProfileWhitelistCache[recipientId] = value;
|
|
return [value boolValue];
|
|
}
|
|
}
|
|
|
|
- (void)addGroupIdToProfileWhitelist:(NSData *)groupId
|
|
{
|
|
OWSAssert(groupId.length > 0);
|
|
|
|
dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
|
|
NSString *groupIdKey = [groupId hexadecimalString];
|
|
|
|
@synchronized(self)
|
|
{
|
|
if ([self isGroupIdInProfileWhitelist:groupId]) {
|
|
return;
|
|
}
|
|
|
|
self.groupProfileWhitelistCache[groupIdKey] = @(YES);
|
|
}
|
|
|
|
[self.dbConnection setBool:YES forKey:groupIdKey inCollection:kOWSProfileManager_GroupWhitelistCollection];
|
|
|
|
[[NSNotificationCenter defaultCenter] postNotificationNameAsync:kNSNotificationName_ProfileWhitelistDidChange
|
|
object:nil
|
|
userInfo:@{
|
|
kNSNotificationKey_ProfileGroupId : groupId,
|
|
}];
|
|
});
|
|
}
|
|
|
|
- (void)addThreadToProfileWhitelist:(TSThread *)thread
|
|
{
|
|
OWSAssert(thread);
|
|
|
|
if (thread.isGroupThread) {
|
|
TSGroupThread *groupThread = (TSGroupThread *)thread;
|
|
NSData *groupId = groupThread.groupModel.groupId;
|
|
[self addGroupIdToProfileWhitelist:groupId];
|
|
|
|
// When we add a group to the profile whitelist, we might as well
|
|
// also add all current members to the profile whitelist
|
|
// individually as well just in case delivery of the profile key
|
|
// fails.
|
|
for (NSString *recipientId in groupThread.recipientIdentifiers) {
|
|
[self addUserToProfileWhitelist:recipientId];
|
|
}
|
|
} else {
|
|
NSString *recipientId = thread.contactIdentifier;
|
|
[self addUserToProfileWhitelist:recipientId];
|
|
}
|
|
}
|
|
|
|
- (BOOL)isGroupIdInProfileWhitelist:(NSData *)groupId
|
|
{
|
|
OWSAssert(groupId.length > 0);
|
|
|
|
@synchronized(self)
|
|
{
|
|
NSString *groupIdKey = [groupId hexadecimalString];
|
|
NSNumber *_Nullable value = self.groupProfileWhitelistCache[groupIdKey];
|
|
if (value) {
|
|
return [value boolValue];
|
|
}
|
|
|
|
value = @(nil !=
|
|
[self.dbConnection objectForKey:groupIdKey inCollection:kOWSProfileManager_GroupWhitelistCollection]);
|
|
self.groupProfileWhitelistCache[groupIdKey] = value;
|
|
return [value boolValue];
|
|
}
|
|
}
|
|
|
|
- (BOOL)isThreadInProfileWhitelist:(TSThread *)thread
|
|
{
|
|
OWSAssert(thread);
|
|
|
|
if (thread.isGroupThread) {
|
|
TSGroupThread *groupThread = (TSGroupThread *)thread;
|
|
NSData *groupId = groupThread.groupModel.groupId;
|
|
return [self isGroupIdInProfileWhitelist:groupId];
|
|
} else {
|
|
NSString *recipientId = thread.contactIdentifier;
|
|
return [self isUserInProfileWhitelist:recipientId];
|
|
}
|
|
}
|
|
|
|
- (void)setContactRecipientIds:(NSArray<NSString *> *)contactRecipientIds
|
|
{
|
|
OWSAssert(contactRecipientIds);
|
|
|
|
[self addUsersToProfileWhitelist:contactRecipientIds];
|
|
}
|
|
|
|
#pragma mark - Other User's Profiles
|
|
|
|
- (void)logUserProfiles
|
|
{
|
|
dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
|
|
@synchronized(self)
|
|
{
|
|
DDLogError(@"logUserProfiles: %zd", [self.dbConnection numberOfKeysInCollection:UserProfile.collection]);
|
|
[self.dbConnection readWithBlock:^(YapDatabaseReadTransaction *transaction) {
|
|
[transaction
|
|
enumerateKeysAndObjectsInCollection:UserProfile.collection
|
|
usingBlock:^(
|
|
NSString *_Nonnull key, id _Nonnull object, BOOL *_Nonnull stop) {
|
|
OWSAssert([object isKindOfClass:[UserProfile class]]);
|
|
UserProfile *userProfile = object;
|
|
DDLogError(@"\t [%@]: has profile key: %d, has avatar URL: %d, has "
|
|
@"avatar file: %d, name: %@",
|
|
userProfile.recipientId,
|
|
userProfile.profileKey != nil,
|
|
userProfile.avatarUrlPath != nil,
|
|
userProfile.avatarFileName != nil,
|
|
userProfile.profileName);
|
|
}];
|
|
}];
|
|
}
|
|
});
|
|
}
|
|
|
|
- (void)setProfileKeyData:(NSData *)profileKeyData forRecipientId:(NSString *)recipientId;
|
|
{
|
|
dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
|
|
@synchronized(self)
|
|
{
|
|
OWSAES256Key *_Nullable profileKey = [OWSAES256Key keyWithData:profileKeyData];
|
|
if (profileKey == nil) {
|
|
OWSFail(@"Failed to make profile key for key data");
|
|
return;
|
|
}
|
|
|
|
UserProfile *userProfile = [self getOrBuildUserProfileForRecipientId:recipientId];
|
|
OWSAssert(userProfile);
|
|
if (userProfile.profileKey && [userProfile.profileKey.keyData isEqual:profileKey.keyData]) {
|
|
// Ignore redundant update.
|
|
return;
|
|
}
|
|
|
|
userProfile.profileKey = profileKey;
|
|
|
|
// Clear profile state.
|
|
userProfile.profileName = nil;
|
|
userProfile.avatarUrlPath = nil;
|
|
userProfile.avatarFileName = nil;
|
|
|
|
[self saveUserProfile:userProfile];
|
|
|
|
[self refreshProfileForRecipientId:recipientId ignoreThrottling:YES];
|
|
}
|
|
});
|
|
}
|
|
|
|
- (nullable NSData *)profileKeyDataForRecipientId:(NSString *)recipientId
|
|
{
|
|
return [self profileKeyForRecipientId:recipientId].keyData;
|
|
}
|
|
|
|
- (nullable OWSAES256Key *)profileKeyForRecipientId:(NSString *)recipientId
|
|
{
|
|
OWSAssert(recipientId.length > 0);
|
|
|
|
@synchronized(self)
|
|
{
|
|
UserProfile *userProfile = [self getOrBuildUserProfileForRecipientId:recipientId];
|
|
OWSAssert(userProfile);
|
|
return userProfile.profileKey;
|
|
}
|
|
}
|
|
|
|
- (nullable NSString *)profileNameForRecipientId:(NSString *)recipientId
|
|
{
|
|
OWSAssert(recipientId.length > 0);
|
|
|
|
[self refreshProfileForRecipientId:recipientId];
|
|
|
|
@synchronized(self)
|
|
{
|
|
UserProfile *userProfile = [self getOrBuildUserProfileForRecipientId:recipientId];
|
|
return userProfile.profileName;
|
|
return self.localUserProfile.profileName;
|
|
}
|
|
}
|
|
|
|
- (nullable UIImage *)profileAvatarForRecipientId:(NSString *)recipientId
|
|
{
|
|
OWSAssert(recipientId.length > 0);
|
|
|
|
[self refreshProfileForRecipientId:recipientId];
|
|
|
|
@synchronized(self)
|
|
{
|
|
UIImage *_Nullable image = [self.otherUsersProfileAvatarImageCache objectForKey:recipientId];
|
|
if (image) {
|
|
return image;
|
|
}
|
|
|
|
UserProfile *userProfile = [self getOrBuildUserProfileForRecipientId:recipientId];
|
|
if (userProfile.avatarFileName.length > 0) {
|
|
image = [self loadProfileAvatarWithFilename:userProfile.avatarFileName];
|
|
if (image) {
|
|
[self.otherUsersProfileAvatarImageCache setObject:image forKey:recipientId];
|
|
}
|
|
} else if (userProfile.avatarUrlPath.length > 0) {
|
|
[self downloadAvatarForUserProfile:userProfile];
|
|
}
|
|
|
|
return image;
|
|
}
|
|
}
|
|
|
|
- (void)downloadAvatarForUserProfile:(UserProfile *)userProfile
|
|
{
|
|
OWSAssert(userProfile);
|
|
|
|
dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
|
|
@synchronized(self)
|
|
{
|
|
if (userProfile.avatarUrlPath.length < 1) {
|
|
OWSFail(@"%@ Malformed avatar URL: %@", self.logTag, userProfile.avatarUrlPath);
|
|
return;
|
|
}
|
|
NSString *_Nullable avatarUrlPathAtStart = userProfile.avatarUrlPath;
|
|
|
|
if (userProfile.profileKey.keyData.length < 1 || userProfile.avatarUrlPath.length < 1) {
|
|
return;
|
|
}
|
|
|
|
OWSAES256Key *profileKeyAtStart = userProfile.profileKey;
|
|
|
|
NSString *fileName = [[NSUUID UUID].UUIDString stringByAppendingPathExtension:@"jpg"];
|
|
NSString *filePath = [self.profileAvatarsDirPath stringByAppendingPathComponent:fileName];
|
|
|
|
if ([self.currentAvatarDownloads containsObject:userProfile.recipientId]) {
|
|
// Download already in flight; ignore.
|
|
return;
|
|
}
|
|
[self.currentAvatarDownloads addObject:userProfile.recipientId];
|
|
|
|
NSString *tempDirectory = NSTemporaryDirectory();
|
|
NSString *tempFilePath = [tempDirectory stringByAppendingPathComponent:fileName];
|
|
|
|
NSURL *avatarUrlPath =
|
|
[NSURL URLWithString:userProfile.avatarUrlPath relativeToURL:self.avatarHTTPManager.baseURL];
|
|
NSURLRequest *request = [NSURLRequest requestWithURL:avatarUrlPath];
|
|
NSURLSessionDownloadTask *downloadTask = [self.avatarHTTPManager downloadTaskWithRequest:request
|
|
progress:^(NSProgress *_Nonnull downloadProgress) {
|
|
DDLogVerbose(@"%@ Downloading avatar for %@ %f",
|
|
self.logTag,
|
|
userProfile.recipientId,
|
|
downloadProgress.fractionCompleted);
|
|
}
|
|
destination:^NSURL *_Nonnull(NSURL *_Nonnull targetPath, NSURLResponse *_Nonnull response) {
|
|
return [NSURL fileURLWithPath:tempFilePath];
|
|
}
|
|
completionHandler:^(
|
|
NSURLResponse *_Nonnull response, NSURL *_Nullable filePathParam, NSError *_Nullable error) {
|
|
// Ensure disk IO and decryption occurs off the main thread.
|
|
dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
|
|
NSData *_Nullable encryptedData = (error ? nil : [NSData dataWithContentsOfFile:tempFilePath]);
|
|
NSData *_Nullable decryptedData =
|
|
[self decryptProfileData:encryptedData profileKey:profileKeyAtStart];
|
|
UIImage *_Nullable image = nil;
|
|
if (decryptedData) {
|
|
BOOL success = [decryptedData writeToFile:filePath atomically:YES];
|
|
if (success) {
|
|
image = [UIImage imageWithContentsOfFile:filePath];
|
|
}
|
|
}
|
|
|
|
@synchronized(self)
|
|
{
|
|
[self.currentAvatarDownloads removeObject:userProfile.recipientId];
|
|
|
|
UserProfile *latestUserProfile =
|
|
[self getOrBuildUserProfileForRecipientId:userProfile.recipientId];
|
|
if (latestUserProfile.profileKey.keyData.length < 1
|
|
|| ![latestUserProfile.profileKey isEqual:userProfile.profileKey]) {
|
|
DDLogWarn(@"%@ Ignoring avatar download for obsolete user profile.", self.logTag);
|
|
} else if (![avatarUrlPathAtStart isEqualToString:latestUserProfile.avatarUrlPath]) {
|
|
DDLogInfo(@"%@ avatar url has changed during download", self.logTag);
|
|
if (latestUserProfile.avatarUrlPath.length > 0) {
|
|
[self downloadAvatarForUserProfile:latestUserProfile];
|
|
}
|
|
} else if (error) {
|
|
DDLogError(@"%@ avatar download failed: %@", self.logTag, error);
|
|
} else if (!encryptedData) {
|
|
DDLogError(@"%@ avatar encrypted data could not be read.", self.logTag);
|
|
} else if (!decryptedData) {
|
|
DDLogError(@"%@ avatar data could not be decrypted.", self.logTag);
|
|
} else if (!image) {
|
|
DDLogError(@"%@ avatar image could not be loaded: %@", self.logTag, error);
|
|
} else {
|
|
[self.otherUsersProfileAvatarImageCache setObject:image forKey:userProfile.recipientId];
|
|
|
|
userProfile.avatarFileName = fileName;
|
|
|
|
[self saveUserProfile:userProfile];
|
|
}
|
|
|
|
// If we're updating the profile that corresponds to our local number,
|
|
// update the local profile as well.
|
|
NSString *_Nullable localNumber = [TSAccountManager sharedInstance].localNumber;
|
|
if (localNumber && [localNumber isEqualToString:userProfile.recipientId]) {
|
|
UserProfile *localUserProfile = self.localUserProfile;
|
|
OWSAssert(localUserProfile);
|
|
localUserProfile.avatarFileName = fileName;
|
|
[self saveUserProfile:localUserProfile];
|
|
self.localCachedAvatarImage = image;
|
|
}
|
|
}
|
|
});
|
|
}];
|
|
[downloadTask resume];
|
|
}
|
|
});
|
|
}
|
|
|
|
- (void)refreshProfileForRecipientId:(NSString *)recipientId
|
|
{
|
|
[self refreshProfileForRecipientId:recipientId ignoreThrottling:NO];
|
|
}
|
|
|
|
- (void)refreshProfileForRecipientId:(NSString *)recipientId ignoreThrottling:(BOOL)ignoreThrottling
|
|
{
|
|
OWSAssert(recipientId.length > 0);
|
|
|
|
dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
|
|
@synchronized(self)
|
|
{
|
|
UserProfile *userProfile = [self getOrBuildUserProfileForRecipientId:recipientId];
|
|
|
|
if (!userProfile.profileKey) {
|
|
// There's no point in fetching the profile for a user
|
|
// if we don't have their profile key; we won't be able
|
|
// to decrypt it.
|
|
return;
|
|
}
|
|
|
|
// Throttle and debounce the updates.
|
|
const NSTimeInterval kMaxRefreshFrequency = 5 * kMinuteInterval;
|
|
if (userProfile.lastUpdateDate
|
|
&& fabs([userProfile.lastUpdateDate timeIntervalSinceNow]) < kMaxRefreshFrequency) {
|
|
// This profile was updated recently or already has an update in flight.
|
|
return;
|
|
}
|
|
|
|
userProfile.lastUpdateDate = [NSDate new];
|
|
|
|
[self saveUserProfile:userProfile];
|
|
|
|
dispatch_async(dispatch_get_main_queue(), ^{
|
|
[ProfileFetcherJob runWithRecipientId:recipientId
|
|
networkManager:self.networkManager
|
|
ignoreThrottling:ignoreThrottling];
|
|
});
|
|
}
|
|
});
|
|
}
|
|
|
|
- (void)updateProfileForRecipientId:(NSString *)recipientId
|
|
profileNameEncrypted:(nullable NSData *)profileNameEncrypted
|
|
avatarUrlPath:(nullable NSString *)avatarUrlPath;
|
|
{
|
|
OWSAssert(recipientId.length > 0);
|
|
|
|
DDLogDebug(@"%@ update profile for: %@ name: %@ avatar: %@",
|
|
self.logTag,
|
|
recipientId,
|
|
profileNameEncrypted,
|
|
avatarUrlPath);
|
|
|
|
// Ensure decryption, etc. off main thread.
|
|
dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
|
|
@synchronized(self)
|
|
{
|
|
UserProfile *userProfile = [self getOrBuildUserProfileForRecipientId:recipientId];
|
|
if (!userProfile.profileKey) {
|
|
return;
|
|
}
|
|
|
|
NSString *_Nullable profileName =
|
|
[self decryptProfileNameData:profileNameEncrypted profileKey:userProfile.profileKey];
|
|
|
|
BOOL isAvatarSame = [self isNullableStringEqual:userProfile.avatarUrlPath toString:avatarUrlPath];
|
|
|
|
userProfile.profileName = profileName;
|
|
userProfile.avatarUrlPath = avatarUrlPath;
|
|
userProfile.avatarFileName = nil;
|
|
|
|
// If we're updating the profile that corresponds to our local number,
|
|
// update the local profile as well.
|
|
NSString *_Nullable localNumber = [TSAccountManager sharedInstance].localNumber;
|
|
if (localNumber && [localNumber isEqualToString:recipientId]) {
|
|
UserProfile *localUserProfile = self.localUserProfile;
|
|
OWSAssert(localUserProfile);
|
|
localUserProfile.profileName = profileName;
|
|
localUserProfile.avatarUrlPath = avatarUrlPath;
|
|
// Don't clear avatarFileName and localCachedAvatarImage optimistically.
|
|
// * The profile avatar probably isn't out of sync.
|
|
// * If the profile avatar is out of sync, it can be synced on next app launch.
|
|
// * We don't want to touch local avatar state until we've
|
|
// downloaded the latest avatar by downloadAvatarForUserProfile.
|
|
[self saveUserProfile:localUserProfile];
|
|
}
|
|
|
|
if (!isAvatarSame) {
|
|
// Evacuate avatar image cache.
|
|
[self.otherUsersProfileAvatarImageCache removeObjectForKey:recipientId];
|
|
|
|
if (avatarUrlPath) {
|
|
[self downloadAvatarForUserProfile:userProfile];
|
|
}
|
|
}
|
|
|
|
userProfile.lastUpdateDate = [NSDate new];
|
|
|
|
[self saveUserProfile:userProfile];
|
|
}
|
|
});
|
|
}
|
|
|
|
- (BOOL)isNullableDataEqual:(NSData *_Nullable)left toData:(NSData *_Nullable)right
|
|
{
|
|
if (left == nil && right == nil) {
|
|
return YES;
|
|
} else if (left == nil || right == nil) {
|
|
return YES;
|
|
} else {
|
|
return [left isEqual:right];
|
|
}
|
|
}
|
|
|
|
- (BOOL)isNullableStringEqual:(NSString *_Nullable)left toString:(NSString *_Nullable)right
|
|
{
|
|
if (left == nil && right == nil) {
|
|
return YES;
|
|
} else if (left == nil || right == nil) {
|
|
return YES;
|
|
} else {
|
|
return [left isEqualToString:right];
|
|
}
|
|
}
|
|
|
|
#pragma mark - Profile Encryption
|
|
|
|
- (nullable NSData *)encryptProfileData:(nullable NSData *)encryptedData profileKey:(OWSAES256Key *)profileKey
|
|
{
|
|
OWSAssert(profileKey.keyData.length == kAES256_KeyByteLength);
|
|
|
|
if (!encryptedData) {
|
|
return nil;
|
|
}
|
|
|
|
return [Cryptography encryptAESGCMWithData:encryptedData key:profileKey];
|
|
}
|
|
|
|
- (nullable NSData *)decryptProfileData:(nullable NSData *)encryptedData profileKey:(OWSAES256Key *)profileKey
|
|
{
|
|
OWSAssert(profileKey.keyData.length == kAES256_KeyByteLength);
|
|
|
|
if (!encryptedData) {
|
|
return nil;
|
|
}
|
|
|
|
return [Cryptography decryptAESGCMWithData:encryptedData key:profileKey];
|
|
}
|
|
|
|
- (nullable NSString *)decryptProfileNameData:(nullable NSData *)encryptedData profileKey:(OWSAES256Key *)profileKey
|
|
{
|
|
OWSAssert(profileKey.keyData.length == kAES256_KeyByteLength);
|
|
|
|
NSData *_Nullable decryptedData = [self decryptProfileData:encryptedData profileKey:profileKey];
|
|
if (decryptedData.length < 1) {
|
|
return nil;
|
|
}
|
|
|
|
|
|
// Unpad profile name.
|
|
NSUInteger unpaddedLength = 0;
|
|
const char *bytes = decryptedData.bytes;
|
|
|
|
// Work through the bytes until we encounter our first
|
|
// padding byte (our padding scheme is NULL bytes)
|
|
for (NSUInteger i = 0; i < decryptedData.length; i++) {
|
|
if (bytes[i] == 0x00) {
|
|
break;
|
|
}
|
|
unpaddedLength = i + 1;
|
|
}
|
|
|
|
NSData *unpaddedData = [decryptedData subdataWithRange:NSMakeRange(0, unpaddedLength)];
|
|
|
|
return [[NSString alloc] initWithData:unpaddedData encoding:NSUTF8StringEncoding];
|
|
}
|
|
|
|
- (nullable NSData *)encryptProfileData:(nullable NSData *)data
|
|
{
|
|
return [self encryptProfileData:data profileKey:self.localProfileKey];
|
|
}
|
|
|
|
- (BOOL)isProfileNameTooLong:(nullable NSString *)profileName
|
|
{
|
|
OWSAssert([NSThread isMainThread]);
|
|
|
|
NSData *nameData = [profileName dataUsingEncoding:NSUTF8StringEncoding];
|
|
return nameData.length > kOWSProfileManager_NameDataLength;
|
|
}
|
|
|
|
- (nullable NSData *)encryptProfileNameWithUnpaddedName:(NSString *)name
|
|
{
|
|
NSData *nameData = [name dataUsingEncoding:NSUTF8StringEncoding];
|
|
if (nameData.length > kOWSProfileManager_NameDataLength) {
|
|
OWSFail(@"%@ name data is too long with length:%lu", self.logTag, (unsigned long)nameData.length);
|
|
return nil;
|
|
}
|
|
|
|
NSUInteger paddingByteCount = kOWSProfileManager_NameDataLength - nameData.length;
|
|
|
|
NSMutableData *paddedNameData = [nameData mutableCopy];
|
|
// Since we want all encrypted profile names to be the same length on the server, we use `increaseLengthBy`
|
|
// to pad out any remaining length with 0 bytes.
|
|
[paddedNameData increaseLengthBy:paddingByteCount];
|
|
OWSAssert(paddedNameData.length == kOWSProfileManager_NameDataLength);
|
|
|
|
return [self encryptProfileData:[paddedNameData copy] profileKey:self.localProfileKey];
|
|
}
|
|
|
|
#pragma mark - Avatar Disk Cache
|
|
|
|
- (nullable NSData *)loadProfileDataWithFilename:(NSString *)filename
|
|
{
|
|
OWSAssert(filename.length > 0);
|
|
|
|
NSString *filePath = [self.profileAvatarsDirPath stringByAppendingPathComponent:filename];
|
|
return [NSData dataWithContentsOfFile:filePath];
|
|
}
|
|
|
|
- (nullable UIImage *)loadProfileAvatarWithFilename:(NSString *)filename
|
|
{
|
|
OWSAssert(filename.length > 0);
|
|
|
|
NSData *data = [self loadProfileDataWithFilename:filename];
|
|
if (![data ows_isValidImage]) {
|
|
return nil;
|
|
}
|
|
UIImage *_Nullable image = [UIImage imageWithData:data];
|
|
return image;
|
|
}
|
|
|
|
- (NSString *)profileAvatarsDirPath
|
|
{
|
|
static NSString *profileAvatarsDirPath = nil;
|
|
static dispatch_once_t onceToken;
|
|
dispatch_once(&onceToken, ^{
|
|
NSString *documentDirPath = [OWSFileSystem appDocumentDirectoryPath];
|
|
NSString *sharedDataDirPath = [OWSFileSystem appSharedDataDirectoryPath];
|
|
|
|
NSString *oldProfileAvatarsDirPath = [documentDirPath stringByAppendingPathComponent:@"ProfileAvatars"];
|
|
NSString *newProfileAvatarsDirPath = [sharedDataDirPath stringByAppendingPathComponent:@"ProfileAvatars"];
|
|
|
|
[OWSFileSystem moveAppFilePath:oldProfileAvatarsDirPath
|
|
sharedDataFilePath:newProfileAvatarsDirPath
|
|
exceptionName:@"ProfileManagerCouldNotMigrateProfileDirectory"];
|
|
|
|
profileAvatarsDirPath = newProfileAvatarsDirPath;
|
|
|
|
BOOL isDirectory;
|
|
BOOL exists = [[NSFileManager defaultManager] fileExistsAtPath:profileAvatarsDirPath isDirectory:&isDirectory];
|
|
if (exists) {
|
|
OWSAssert(isDirectory);
|
|
|
|
DDLogInfo(@"Profile avatars directory already exists");
|
|
} else {
|
|
NSError *error = nil;
|
|
[[NSFileManager defaultManager] createDirectoryAtPath:profileAvatarsDirPath
|
|
withIntermediateDirectories:YES
|
|
attributes:nil
|
|
error:&error];
|
|
if (error) {
|
|
DDLogError(@"Failed to create profile avatars directory: %@", error);
|
|
}
|
|
}
|
|
|
|
[OWSFileSystem protectFolderAtPath:profileAvatarsDirPath];
|
|
});
|
|
return profileAvatarsDirPath;
|
|
}
|
|
|
|
// TODO: We may want to clean up this directory in the "orphan cleanup" logic.
|
|
|
|
- (void)resetProfileStorage
|
|
{
|
|
OWSAssert([NSThread isMainThread]);
|
|
|
|
NSError *error;
|
|
[[NSFileManager defaultManager] removeItemAtPath:[self profileAvatarsDirPath] error:&error];
|
|
if (error) {
|
|
DDLogError(@"Failed to delete database: %@", error.description);
|
|
}
|
|
}
|
|
|
|
#pragma mark - User Interface
|
|
|
|
- (void)presentAddThreadToProfileWhitelist:(TSThread *)thread
|
|
fromViewController:(UIViewController *)fromViewController
|
|
success:(void (^)(void))successHandler
|
|
{
|
|
AssertIsOnMainThread();
|
|
|
|
UIAlertController *alertController =
|
|
[UIAlertController alertControllerWithTitle:nil message:nil preferredStyle:UIAlertControllerStyleActionSheet];
|
|
|
|
NSString *shareTitle = NSLocalizedString(@"CONVERSATION_SETTINGS_VIEW_SHARE_PROFILE",
|
|
@"Button to confirm that user wants to share their profile with a user or group.");
|
|
[alertController addAction:[UIAlertAction actionWithTitle:shareTitle
|
|
style:UIAlertActionStyleDefault
|
|
handler:^(UIAlertAction *_Nonnull action) {
|
|
[self userAddedThreadToProfileWhitelist:thread
|
|
success:successHandler];
|
|
}]];
|
|
[alertController addAction:[OWSAlerts cancelAction]];
|
|
|
|
[fromViewController presentViewController:alertController animated:YES completion:nil];
|
|
}
|
|
|
|
- (void)userAddedThreadToProfileWhitelist:(TSThread *)thread success:(void (^)(void))successHandler
|
|
{
|
|
AssertIsOnMainThread();
|
|
|
|
OWSProfileKeyMessage *message =
|
|
[[OWSProfileKeyMessage alloc] initWithTimestamp:[NSDate ows_millisecondTimeStamp] inThread:thread];
|
|
|
|
BOOL isFeatureEnabled = NO;
|
|
if (!isFeatureEnabled) {
|
|
DDLogWarn(
|
|
@"%@ skipping sending profile-key message because the feature is not yet fully available.", self.logTag);
|
|
[OWSProfileManager.sharedManager addThreadToProfileWhitelist:thread];
|
|
successHandler();
|
|
return;
|
|
}
|
|
|
|
[self.messageSender enqueueMessage:message
|
|
success:^{
|
|
DDLogInfo(@"%@ Successfully sent profile key message to thread: %@", self.logTag, thread);
|
|
[OWSProfileManager.sharedManager addThreadToProfileWhitelist:thread];
|
|
|
|
dispatch_async(dispatch_get_main_queue(), ^{
|
|
successHandler();
|
|
});
|
|
}
|
|
failure:^(NSError *_Nonnull error) {
|
|
dispatch_async(dispatch_get_main_queue(), ^{
|
|
DDLogError(@"%@ Failed to send profile key message to thread: %@", self.logTag, thread);
|
|
});
|
|
}];
|
|
}
|
|
|
|
#pragma mark - Notifications
|
|
|
|
- (void)applicationDidBecomeActive:(NSNotification *)notification
|
|
{
|
|
OWSAssert([NSThread isMainThread]);
|
|
|
|
@synchronized(self)
|
|
{
|
|
// TODO: Sync if necessary.
|
|
}
|
|
}
|
|
|
|
@end
|
|
|
|
NS_ASSUME_NONNULL_END
|