mirror of
https://github.com/wahyd4/Yep.git
synced 2026-08-10 21:36:49 +10:00
3980 lines
165 KiB
Swift
3980 lines
165 KiB
Swift
//
|
|
// ConversationViewController.swift
|
|
// Yep
|
|
//
|
|
// Created by NIX on 15/3/23.
|
|
// Copyright (c) 2015年 Catch Inc. All rights reserved.
|
|
//
|
|
|
|
import UIKit
|
|
import RealmSwift
|
|
import AVFoundation
|
|
import MobileCoreServices
|
|
import MapKit
|
|
import Proposer
|
|
import KeyboardMan
|
|
import Navi
|
|
import MonkeyKing
|
|
|
|
struct MessageNotification {
|
|
static let MessageStateChanged = "MessageStateChangedNotification"
|
|
static let MessageBatchMarkAsRead = "MessageBatchMarkAsReadNotification"
|
|
}
|
|
|
|
enum ConversationFeed {
|
|
case DiscoveredFeedType(DiscoveredFeed)
|
|
case FeedType(Feed)
|
|
|
|
var feedID: String {
|
|
switch self {
|
|
case .DiscoveredFeedType(let discoveredFeed):
|
|
return discoveredFeed.id
|
|
|
|
case .FeedType(let feed):
|
|
return feed.feedID
|
|
}
|
|
}
|
|
|
|
var body: String {
|
|
switch self {
|
|
case .DiscoveredFeedType(let discoveredFeed):
|
|
return discoveredFeed.body
|
|
|
|
case .FeedType(let feed):
|
|
return feed.body
|
|
}
|
|
}
|
|
|
|
var creator: User? {
|
|
switch self {
|
|
case .DiscoveredFeedType(let discoveredFeed):
|
|
guard let realm = try? Realm() else {
|
|
return nil
|
|
}
|
|
return getOrCreateUserWithDiscoverUser(discoveredFeed.creator, inRealm: realm)
|
|
|
|
case .FeedType(let feed):
|
|
return feed.creator
|
|
}
|
|
}
|
|
|
|
var distance: Double? {
|
|
switch self {
|
|
case .DiscoveredFeedType(let discoveredFeed):
|
|
return discoveredFeed.distance
|
|
|
|
case .FeedType(let feed):
|
|
return feed.distance
|
|
}
|
|
}
|
|
|
|
var attachments: [Attachment] {
|
|
switch self {
|
|
case .DiscoveredFeedType(let discoveredFeed):
|
|
return attachmentFromDiscoveredAttachment(discoveredFeed.attachments, inRealm: nil)
|
|
|
|
case .FeedType(let feed):
|
|
return Array(feed.attachments)
|
|
}
|
|
}
|
|
|
|
var createdUnixTime: NSTimeInterval {
|
|
switch self {
|
|
case .DiscoveredFeedType(let discoveredFeed):
|
|
return discoveredFeed.createdUnixTime
|
|
|
|
case .FeedType(let feed):
|
|
return feed.createdUnixTime
|
|
}
|
|
}
|
|
}
|
|
|
|
class ConversationViewController: BaseViewController {
|
|
|
|
var conversationFeed: ConversationFeed?
|
|
|
|
var conversation: Conversation!
|
|
|
|
var selectedIndexPathForMenu: NSIndexPath?
|
|
|
|
var realm: Realm!
|
|
|
|
var groupShareURLString: String?
|
|
|
|
lazy var messages: Results<Message> = {
|
|
return messagesOfConversation(self.conversation, inRealm: self.realm)
|
|
}()
|
|
|
|
let messagesBunchCount = 10 // TODO: 分段载入的“一束”消息的数量
|
|
var displayedMessagesRange = NSRange()
|
|
|
|
// 上一次更新 UI 时的消息数
|
|
var lastTimeMessagesCount: Int = 0
|
|
|
|
// 位于后台时收到的消息
|
|
var inActiveNewMessageIDSet = Set<String>()
|
|
|
|
var afterSentMessageAction: (() -> Void)?
|
|
|
|
var afterDeletedConversationAction: (() -> Void)?
|
|
|
|
lazy var sectionDateFormatter: NSDateFormatter = {
|
|
let dateFormatter = NSDateFormatter()
|
|
dateFormatter.dateStyle = .ShortStyle
|
|
dateFormatter.timeStyle = .ShortStyle
|
|
return dateFormatter
|
|
}()
|
|
|
|
lazy var sectionDateInCurrentWeekFormatter: NSDateFormatter = {
|
|
let dateFormatter = NSDateFormatter()
|
|
dateFormatter.dateFormat = "EEEE HH:mm"
|
|
return dateFormatter
|
|
}()
|
|
|
|
var messagePreviewTransitionManager: ConversationMessagePreviewTransitionManager?
|
|
var navigationControllerDelegate: ConversationMessagePreviewNavigationControllerDelegate?
|
|
|
|
var conversationCollectionViewHasBeenMovedToBottomOnce = false
|
|
|
|
var checkTypingStatusTimer: NSTimer?
|
|
var typingResetDelay: Float = 0
|
|
|
|
// KeyboardMan 帮助我们做键盘动画
|
|
let keyboardMan = KeyboardMan()
|
|
var giveUpKeyboardHideAnimationWhenViewControllerDisapeear = false
|
|
|
|
var isFirstAppear = true
|
|
|
|
lazy var titleView: ConversationTitleView = {
|
|
let titleView = ConversationTitleView(frame: CGRect(origin: CGPointZero, size: CGSize(width: 150, height: 44)))
|
|
|
|
if nameOfConversation(self.conversation) != "" {
|
|
titleView.nameLabel.text = nameOfConversation(self.conversation)
|
|
} else {
|
|
titleView.nameLabel.text = NSLocalizedString("Discussion", comment: "")
|
|
}
|
|
|
|
self.updateStateInfoOfTitleView(titleView)
|
|
|
|
titleView.userInteractionEnabled = true
|
|
|
|
let tap = UITapGestureRecognizer(target: self, action: "showProfile")
|
|
|
|
titleView.addGestureRecognizer(tap)
|
|
|
|
return titleView
|
|
}()
|
|
|
|
lazy var moreView: ConversationMoreView = ConversationMoreView()
|
|
|
|
lazy var moreMessageTypesView: MoreMessageTypesView = {
|
|
|
|
let view = MoreMessageTypesView()
|
|
|
|
view.alertCanNotAccessCameraRollAction = { [weak self] in
|
|
self?.alertCanNotAccessCameraRoll()
|
|
}
|
|
|
|
view.sendImageAction = { [weak self] image in
|
|
self?.sendImage(image)
|
|
}
|
|
|
|
view.takePhotoAction = { [weak self] in
|
|
|
|
let openCamera: ProposerAction = { [weak self] in
|
|
if UIImagePickerController.isSourceTypeAvailable(UIImagePickerControllerSourceType.Camera) {
|
|
if let strongSelf = self {
|
|
strongSelf.imagePicker.sourceType = .Camera
|
|
strongSelf.presentViewController(strongSelf.imagePicker, animated: true, completion: nil)
|
|
}
|
|
}
|
|
}
|
|
|
|
proposeToAccess(.Camera, agreed: openCamera, rejected: {
|
|
self?.alertCanNotOpenCamera()
|
|
})
|
|
}
|
|
|
|
view.choosePhotoAction = { [weak self] in
|
|
|
|
let openCameraRoll: ProposerAction = { [weak self] in
|
|
if UIImagePickerController.isSourceTypeAvailable(UIImagePickerControllerSourceType.PhotoLibrary){
|
|
if let strongSelf = self {
|
|
strongSelf.imagePicker.sourceType = .PhotoLibrary
|
|
strongSelf.presentViewController(strongSelf.imagePicker, animated: true, completion: nil)
|
|
}
|
|
}
|
|
}
|
|
|
|
proposeToAccess(.Photos, agreed: openCameraRoll, rejected: {
|
|
self?.alertCanNotAccessCameraRoll()
|
|
})
|
|
}
|
|
|
|
view.pickLocationAction = { [weak self] in
|
|
self?.performSegueWithIdentifier("presentPickLocation", sender: nil)
|
|
}
|
|
|
|
return view
|
|
}()
|
|
|
|
lazy var pullToRefreshView: PullToRefreshView = {
|
|
|
|
let pullToRefreshView = PullToRefreshView()
|
|
pullToRefreshView.delegate = self
|
|
|
|
self.conversationCollectionView.insertSubview(pullToRefreshView, atIndex: 0)
|
|
|
|
pullToRefreshView.translatesAutoresizingMaskIntoConstraints = false
|
|
|
|
let viewsDictionary = [
|
|
"pullToRefreshView": pullToRefreshView,
|
|
"view": self.view,
|
|
]
|
|
|
|
let constraintsV = NSLayoutConstraint.constraintsWithVisualFormat("V:|-(-200)-[pullToRefreshView(200)]", options: NSLayoutFormatOptions(rawValue: 0), metrics: nil, views: viewsDictionary)
|
|
|
|
// 非常奇怪，若直接用 "H:|[pullToRefreshView]|" 得到的实际宽度为 0
|
|
let constraintsH = NSLayoutConstraint.constraintsWithVisualFormat("H:|[pullToRefreshView(==view)]|", options: NSLayoutFormatOptions(rawValue: 0), metrics: nil, views: viewsDictionary)
|
|
|
|
NSLayoutConstraint.activateConstraints(constraintsV)
|
|
NSLayoutConstraint.activateConstraints(constraintsH)
|
|
|
|
return pullToRefreshView
|
|
}()
|
|
|
|
lazy var waverView: YepWaverView = {
|
|
let frame = self.view.bounds
|
|
let view = YepWaverView(frame: frame)
|
|
|
|
view.waver.waverCallback = { waver in
|
|
|
|
if let audioRecorder = YepAudioService.sharedManager.audioRecorder {
|
|
|
|
if (audioRecorder.recording) {
|
|
//println("Update waver")
|
|
audioRecorder.updateMeters()
|
|
|
|
let normalizedValue = pow(10, audioRecorder.averagePowerForChannel(0)/40)
|
|
|
|
waver.level = CGFloat(normalizedValue)
|
|
}
|
|
}
|
|
}
|
|
|
|
return view
|
|
}()
|
|
var samplesCount = 0
|
|
let samplingInterval = 6
|
|
|
|
var feedView: FeedView?
|
|
var dragBeginLocation: CGPoint?
|
|
|
|
@IBOutlet weak var conversationCollectionView: UICollectionView!
|
|
let conversationCollectionViewContentInsetYOffset: CGFloat = 10
|
|
|
|
@IBOutlet weak var messageToolbar: MessageToolbar!
|
|
@IBOutlet weak var messageToolbarBottomConstraint: NSLayoutConstraint!
|
|
|
|
//@IBOutlet weak var moreMessageTypesView: UIView!
|
|
//@IBOutlet weak var moreMessageTypesViewHeightConstraint: NSLayoutConstraint!
|
|
//let moreMessageTypesViewDefaultHeight: CGFloat = 110
|
|
|
|
//@IBOutlet weak var choosePhotoButton: MessageTypeButton!
|
|
//@IBOutlet weak var takePhotoButton: MessageTypeButton!
|
|
//@IBOutlet weak var addLocationButton: MessageTypeButton!
|
|
|
|
@IBOutlet weak var swipeUpView: UIView!
|
|
@IBOutlet weak var swipeUpPromptLabel: UILabel!
|
|
|
|
@IBOutlet weak var activityIndicator: UIActivityIndicatorView!
|
|
|
|
var isTryingShowFriendRequestView = false
|
|
|
|
var originalNavigationControllerDelegate: UINavigationControllerDelegate?
|
|
|
|
let sectionInsetTop: CGFloat = 10
|
|
let sectionInsetBottom: CGFloat = 10
|
|
|
|
lazy var messageTextLabelMaxWidth: CGFloat = {
|
|
let maxWidth = self.collectionViewWidth - (YepConfig.chatCellGapBetweenWallAndAvatar() + YepConfig.chatCellAvatarSize() + YepConfig.chatCellGapBetweenTextContentLabelAndAvatar() + YepConfig.chatTextGapBetweenWallAndContentLabel())
|
|
return maxWidth
|
|
}()
|
|
|
|
lazy var collectionViewWidth: CGFloat = {
|
|
return CGRectGetWidth(self.conversationCollectionView.bounds)
|
|
}()
|
|
|
|
lazy var messageImagePreferredWidth: CGFloat = {
|
|
return YepConfig.ChatCell.mediaPreferredWidth
|
|
}()
|
|
lazy var messageImagePreferredHeight: CGFloat = {
|
|
return YepConfig.ChatCell.mediaPreferredHeight
|
|
}()
|
|
|
|
let messageImagePreferredAspectRatio: CGFloat = 4.0 / 3.0
|
|
|
|
lazy var imagePicker: UIImagePickerController = {
|
|
let imagePicker = UIImagePickerController()
|
|
imagePicker.delegate = self
|
|
imagePicker.mediaTypes = [kUTTypeImage as String, kUTTypeMovie as String]
|
|
imagePicker.videoQuality = .TypeMedium
|
|
imagePicker.allowsEditing = false
|
|
return imagePicker
|
|
}()
|
|
|
|
let chatSectionDateCellIdentifier = "ChatSectionDateCell"
|
|
let chatStateCellIdentifier = "ChatStateCell"
|
|
let chatLeftTextCellIdentifier = "ChatLeftTextCell"
|
|
let chatRightTextCellIdentifier = "ChatRightTextCell"
|
|
let chatLeftImageCellIdentifier = "ChatLeftImageCell"
|
|
let chatRightImageCellIdentifier = "ChatRightImageCell"
|
|
let chatLeftAudioCellIdentifier = "ChatLeftAudioCell"
|
|
let chatRightAudioCellIdentifier = "ChatRightAudioCell"
|
|
let chatLeftVideoCellIdentifier = "ChatLeftVideoCell"
|
|
let chatRightVideoCellIdentifier = "ChatRightVideoCell"
|
|
let chatLeftLocationCellIdentifier = "ChatLeftLocationCell"
|
|
let chatRightLocationCellIdentifier = "ChatRightLocationCell"
|
|
let chatLeftSocialWorkCellIdentifier = "ChatLeftSocialWorkCell"
|
|
|
|
struct Listener {
|
|
static let Avatar = "ConversationViewController"
|
|
}
|
|
|
|
deinit {
|
|
NSNotificationCenter.defaultCenter().removeObserver(self)
|
|
|
|
YepUserDefaults.avatarURLString.removeListenerWithName(Listener.Avatar)
|
|
|
|
conversationCollectionView?.delegate = nil
|
|
|
|
println("deinit ConversationViewController")
|
|
}
|
|
|
|
|
|
func showProfile() {
|
|
if let user = conversation.withFriend {
|
|
performSegueWithIdentifier("showProfile", sender: user)
|
|
}
|
|
}
|
|
|
|
|
|
override func viewDidLoad() {
|
|
super.viewDidLoad()
|
|
|
|
UIMenuController.sharedMenuController().menuItems = [ UIMenuItem(title: NSLocalizedString("Delete", comment: ""), action: "deleteMessage:") ]
|
|
|
|
realm = try! Realm()
|
|
|
|
// 优先处理侧滑，而不是 scrollView 的上下滚动，避免出现你想侧滑返回的时候，结果触发了 scrollView 的上下滚动
|
|
if let gestures = navigationController?.view.gestureRecognizers {
|
|
for recognizer in gestures {
|
|
if recognizer.isKindOfClass(UIScreenEdgePanGestureRecognizer) {
|
|
conversationCollectionView.panGestureRecognizer.requireGestureRecognizerToFail(recognizer as! UIScreenEdgePanGestureRecognizer)
|
|
println("Require UIScreenEdgePanGestureRecognizer to failed")
|
|
break
|
|
}
|
|
}
|
|
}
|
|
|
|
navigationController?.interactivePopGestureRecognizer?.delaysTouchesBegan = false
|
|
|
|
view.tintAdjustmentMode = .Normal
|
|
|
|
if messages.count >= messagesBunchCount {
|
|
displayedMessagesRange = NSRange(location: Int(messages.count) - messagesBunchCount, length: messagesBunchCount)
|
|
} else {
|
|
displayedMessagesRange = NSRange(location: 0, length: Int(messages.count))
|
|
}
|
|
|
|
lastTimeMessagesCount = messages.count
|
|
|
|
navigationItem.titleView = titleView
|
|
|
|
|
|
let moreBarButtonItem = UIBarButtonItem(image: UIImage(named: "icon_more"), style: UIBarButtonItemStyle.Plain, target: self, action: "moreAction")
|
|
navigationItem.rightBarButtonItem = moreBarButtonItem
|
|
|
|
|
|
NSNotificationCenter.defaultCenter().addObserver(self, selector: "handleReceivedNewMessagesNotification:", name: YepConfig.Notification.newMessages, object: nil)
|
|
|
|
NSNotificationCenter.defaultCenter().addObserver(self, selector: "cleanForLogout", name: EditProfileViewController.Notification.Logout, object: nil)
|
|
|
|
NSNotificationCenter.defaultCenter().addObserver(self, selector: "tryInsertInActiveNewMessages:", name: AppDelegate.Notification.applicationDidBecomeActive, object: nil)
|
|
|
|
NSNotificationCenter.defaultCenter().addObserver(self, selector: "didRecieveMenuWillShowNotification:", name: UIMenuControllerWillShowMenuNotification, object: nil)
|
|
|
|
NSNotificationCenter.defaultCenter().addObserver(self, selector: "didRecieveMenuWillHideNotification:", name: UIMenuControllerWillHideMenuNotification, object: nil)
|
|
|
|
NSNotificationCenter.defaultCenter().addObserver(self, selector: "messagesMarkAsReadByRecipient:", name: MessageNotification.MessageBatchMarkAsRead, object: nil)
|
|
|
|
YepUserDefaults.avatarURLString.bindListener(Listener.Avatar) { [weak self] _ in
|
|
dispatch_async(dispatch_get_main_queue()) {
|
|
self?.reloadConversationCollectionView()
|
|
}
|
|
}
|
|
|
|
swipeUpView.hidden = true
|
|
|
|
conversationCollectionView.keyboardDismissMode = .OnDrag
|
|
|
|
conversationCollectionView.alwaysBounceVertical = true
|
|
|
|
conversationCollectionView.registerNib(UINib(nibName: chatStateCellIdentifier, bundle: nil), forCellWithReuseIdentifier: chatStateCellIdentifier)
|
|
conversationCollectionView.registerNib(UINib(nibName: chatSectionDateCellIdentifier, bundle: nil), forCellWithReuseIdentifier: chatSectionDateCellIdentifier)
|
|
conversationCollectionView.registerNib(UINib(nibName: chatLeftTextCellIdentifier, bundle: nil), forCellWithReuseIdentifier: chatLeftTextCellIdentifier)
|
|
conversationCollectionView.registerNib(UINib(nibName: chatRightTextCellIdentifier, bundle: nil), forCellWithReuseIdentifier: chatRightTextCellIdentifier)
|
|
conversationCollectionView.registerNib(UINib(nibName: chatLeftImageCellIdentifier, bundle: nil), forCellWithReuseIdentifier: chatLeftImageCellIdentifier)
|
|
conversationCollectionView.registerNib(UINib(nibName: chatRightImageCellIdentifier, bundle: nil), forCellWithReuseIdentifier: chatRightImageCellIdentifier)
|
|
conversationCollectionView.registerNib(UINib(nibName: chatLeftAudioCellIdentifier, bundle: nil), forCellWithReuseIdentifier: chatLeftAudioCellIdentifier)
|
|
conversationCollectionView.registerNib(UINib(nibName: chatRightAudioCellIdentifier, bundle: nil), forCellWithReuseIdentifier: chatRightAudioCellIdentifier)
|
|
conversationCollectionView.registerNib(UINib(nibName: chatLeftVideoCellIdentifier, bundle: nil), forCellWithReuseIdentifier: chatLeftVideoCellIdentifier)
|
|
conversationCollectionView.registerNib(UINib(nibName: chatRightVideoCellIdentifier, bundle: nil), forCellWithReuseIdentifier: chatRightVideoCellIdentifier)
|
|
conversationCollectionView.registerNib(UINib(nibName: chatLeftLocationCellIdentifier, bundle: nil), forCellWithReuseIdentifier: chatLeftLocationCellIdentifier)
|
|
conversationCollectionView.registerNib(UINib(nibName: chatRightLocationCellIdentifier, bundle: nil), forCellWithReuseIdentifier: chatRightLocationCellIdentifier)
|
|
conversationCollectionView.registerNib(UINib(nibName: chatLeftSocialWorkCellIdentifier, bundle: nil), forCellWithReuseIdentifier: chatLeftSocialWorkCellIdentifier)
|
|
|
|
conversationCollectionView.bounces = true
|
|
|
|
|
|
let tap = UITapGestureRecognizer(target: self, action: "tapToCollapseMessageToolBar:")
|
|
conversationCollectionView.addGestureRecognizer(tap)
|
|
|
|
messageToolbarBottomConstraint.constant = 0
|
|
//moreMessageTypesViewHeightConstraint.constant = moreMessageTypesViewDefaultHeight
|
|
|
|
keyboardMan.animateWhenKeyboardAppear = { [weak self] appearPostIndex, keyboardHeight, keyboardHeightIncrement in
|
|
|
|
if let giveUp = self?.giveUpKeyboardHideAnimationWhenViewControllerDisapeear {
|
|
|
|
if giveUp {
|
|
self?.giveUpKeyboardHideAnimationWhenViewControllerDisapeear = false
|
|
return
|
|
}
|
|
}
|
|
|
|
println("appear \(keyboardHeight), \(keyboardHeightIncrement)\n")
|
|
|
|
if let strongSelf = self {
|
|
|
|
if strongSelf.messageToolbarBottomConstraint.constant > 0 {
|
|
|
|
// 注意第一次要减去已经有的高度偏移
|
|
if appearPostIndex == 0 {
|
|
strongSelf.conversationCollectionView.contentOffset.y += keyboardHeightIncrement //- strongSelf.moreMessageTypesViewDefaultHeight
|
|
} else {
|
|
strongSelf.conversationCollectionView.contentOffset.y += keyboardHeightIncrement
|
|
}
|
|
|
|
strongSelf.conversationCollectionView.contentInset.bottom = keyboardHeight + strongSelf.messageToolbar.frame.height
|
|
|
|
strongSelf.messageToolbarBottomConstraint.constant = keyboardHeight
|
|
strongSelf.view.layoutIfNeeded()
|
|
|
|
} else {
|
|
strongSelf.conversationCollectionView.contentOffset.y += keyboardHeightIncrement
|
|
strongSelf.conversationCollectionView.contentInset.bottom = keyboardHeight + strongSelf.messageToolbar.frame.height
|
|
|
|
strongSelf.messageToolbarBottomConstraint.constant = keyboardHeight
|
|
strongSelf.view.layoutIfNeeded()
|
|
}
|
|
}
|
|
}
|
|
|
|
keyboardMan.animateWhenKeyboardDisappear = { [weak self] keyboardHeight in
|
|
|
|
if let nvc = self?.navigationController {
|
|
if nvc.topViewController != self {
|
|
self?.giveUpKeyboardHideAnimationWhenViewControllerDisapeear = true
|
|
return
|
|
}
|
|
}
|
|
|
|
println("disappear \(keyboardHeight)\n")
|
|
|
|
if let strongSelf = self {
|
|
|
|
if strongSelf.messageToolbarBottomConstraint.constant > 0 {
|
|
|
|
strongSelf.conversationCollectionView.contentOffset.y -= keyboardHeight
|
|
strongSelf.conversationCollectionView.contentInset.bottom = strongSelf.messageToolbar.frame.height
|
|
|
|
strongSelf.messageToolbarBottomConstraint.constant = 0
|
|
strongSelf.view.layoutIfNeeded()
|
|
}
|
|
|
|
}
|
|
}
|
|
|
|
// sync messages
|
|
|
|
let syncMessages: (failedAction: (() -> Void)?, successAction: (() -> Void)?) -> Void = { failedAction, successAction in
|
|
dispatch_async(dispatch_get_main_queue()) { [weak self] in
|
|
|
|
if let recipient = self?.conversation.recipient {
|
|
|
|
let timeDirection: TimeDirection
|
|
if let minMessageID = self?.messages.last?.messageID {
|
|
timeDirection = .Future(minMessageID: minMessageID)
|
|
} else {
|
|
timeDirection = .None
|
|
|
|
self?.activityIndicator.startAnimating()
|
|
}
|
|
|
|
dispatch_async(realmQueue) { [weak self] in
|
|
|
|
messagesFromRecipient(recipient, withTimeDirection: timeDirection, failureHandler: { reason, errorMessage in
|
|
defaultFailureHandler(reason, errorMessage: errorMessage)
|
|
|
|
failedAction?()
|
|
|
|
}, completion: { messageIDs in
|
|
println("messagesFromRecipient: \(messageIDs.count)")
|
|
|
|
dispatch_async(dispatch_get_main_queue()) { [weak self] in
|
|
tryPostNewMessagesReceivedNotificationWithMessageIDs(messageIDs, messageAge: timeDirection.messageAge)
|
|
//self?.fayeRecievedNewMessages(messageIDs, messageAgeRawValue: timeDirection.messageAge.rawValue)
|
|
|
|
self?.activityIndicator.stopAnimating()
|
|
}
|
|
|
|
successAction?()
|
|
})
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
switch conversation.type {
|
|
|
|
case ConversationType.OneToOne.rawValue:
|
|
syncMessages(failedAction: nil, successAction: nil)
|
|
syncMessagesReadStatus()
|
|
|
|
case ConversationType.Group.rawValue:
|
|
|
|
if let groupID = conversation.withGroup?.groupID {
|
|
|
|
// 新策略：先同步消息，若失败就再次加入，再获取一次
|
|
syncMessages(failedAction: {
|
|
joinGroup(groupID: groupID, failureHandler: nil, completion: {
|
|
syncMessages(failedAction: nil, successAction: nil)
|
|
FayeService.sharedManager.subscribeGroup(groupID: groupID)
|
|
})
|
|
|
|
}, successAction: {
|
|
FayeService.sharedManager.subscribeGroup(groupID: groupID)
|
|
})
|
|
|
|
//joinGroup(groupID: groupID, failureHandler: nil, completion: {
|
|
|
|
//println("joined group: \(groupID)")
|
|
|
|
// groupShareLinkWithGroupID(groupID, failureHandler: nil, completion: { [weak self] link in
|
|
//
|
|
// if let url = link["url"] as? String {
|
|
// self?.groupURL = url
|
|
// }
|
|
//
|
|
// })
|
|
|
|
//syncMessages()
|
|
|
|
//FayeService.sharedManager.subscribeGroup(groupID: groupID)
|
|
|
|
//})
|
|
}
|
|
|
|
default:
|
|
break
|
|
}
|
|
}
|
|
|
|
override func viewWillAppear(animated: Bool) {
|
|
super.viewWillAppear(animated)
|
|
|
|
// 尝试恢复原始的 NavigationControllerDelegate，如果自定义 push 了才需要
|
|
if let delegate = originalNavigationControllerDelegate {
|
|
navigationController?.delegate = delegate
|
|
navigationControllerDelegate = nil
|
|
}
|
|
|
|
if isFirstAppear {
|
|
|
|
if let feed = conversation.withGroup?.withFeed {
|
|
conversationFeed = ConversationFeed.FeedType(feed)
|
|
}
|
|
|
|
if let conversationFeed = conversationFeed {
|
|
makeFeedViewWithFeed(conversationFeed)
|
|
tryFoldFeedView()
|
|
}
|
|
|
|
// 为记录草稿准备
|
|
|
|
messageToolbar.conversation = conversation
|
|
|
|
// MARK: MessageToolbar MoreMessageTypes
|
|
|
|
messageToolbar.moreMessageTypesAction = { [weak self] in
|
|
|
|
if let window = self?.view.window {
|
|
self?.moreMessageTypesView.showInView(window)
|
|
|
|
if let state = self?.messageToolbar.state where !state.isAtBottom {
|
|
self?.messageToolbar.state = .Default
|
|
}
|
|
|
|
delay(0.2) {
|
|
self?.imagePicker.hidesBarsOnTap = false
|
|
}
|
|
}
|
|
}
|
|
|
|
// MARK: MessageToolbar State Transitions
|
|
|
|
messageToolbar.stateTransitionAction = { [weak self] (messageToolbar, previousState, currentState) in
|
|
|
|
switch currentState {
|
|
|
|
case .BeginTextInput:
|
|
self?.tryFoldFeedView()
|
|
|
|
self?.trySnapContentOfConversationCollectionViewToBottom(forceAnimation: true)
|
|
|
|
case .TextInputing:
|
|
self?.trySnapContentOfConversationCollectionViewToBottom()
|
|
|
|
default:
|
|
break
|
|
}
|
|
}
|
|
|
|
// 在这里才尝试恢复 messageToolbar 的状态，因为依赖 stateTransitionAction
|
|
|
|
func tryRecoverMessageToolBar() {
|
|
if let
|
|
draft = conversation.draft,
|
|
state = MessageToolbarState(rawValue: draft.messageToolbarState) {
|
|
|
|
if state == .TextInputing || state == .Default {
|
|
messageToolbar.messageTextView.text = draft.text
|
|
}
|
|
|
|
// 恢复时特别注意：因为键盘改由用户触发，因此
|
|
if state == .TextInputing || state == .BeginTextInput {
|
|
// 这两种状态时不恢复 messageToolbar.state
|
|
return
|
|
}
|
|
|
|
// 这句要放在最后，因为它会触发 stateTransitionAction
|
|
// 只恢复不改变高度的状态
|
|
if state == .VoiceRecord {
|
|
messageToolbar.state = state
|
|
}
|
|
}
|
|
}
|
|
|
|
tryRecoverMessageToolBar()
|
|
}
|
|
}
|
|
|
|
|
|
override func viewDidAppear(animated: Bool) {
|
|
super.viewDidAppear(animated)
|
|
|
|
navigationController?.setNavigationBarHidden(false, animated: true)
|
|
setNeedsStatusBarAppearanceUpdate()
|
|
|
|
conversationCollectionViewHasBeenMovedToBottomOnce = true
|
|
|
|
FayeService.sharedManager.delegate = self
|
|
|
|
// 进来时就尽快标记已读
|
|
|
|
delay(0.1) { [weak self] in
|
|
self?.batchMarkMessagesAsReaded(updateOlderMessagesIfNeeded: true)
|
|
}
|
|
|
|
// MARK: Notify Typing
|
|
|
|
// 为 nil 时才新建
|
|
if checkTypingStatusTimer == nil {
|
|
checkTypingStatusTimer = NSTimer.scheduledTimerWithTimeInterval(1, target: self, selector: Selector("checkTypingStatus"), userInfo: nil, repeats: true)
|
|
}
|
|
|
|
// 尽量晚的设置一些属性和闭包
|
|
|
|
if isFirstAppear {
|
|
|
|
isFirstAppear = false
|
|
|
|
messageToolbar.notifyTypingAction = { [weak self] in
|
|
|
|
if let withFriend = self?.conversation.withFriend {
|
|
|
|
let typingMessage: JSONDictionary = ["state": FayeService.InstantStateType.Text.rawValue]
|
|
|
|
if FayeService.sharedManager.client.connected {
|
|
FayeService.sharedManager.sendPrivateMessage(typingMessage, messageType: .Instant, userID: withFriend.userID, completion: { (result, messageID) in
|
|
println("Send typing \(result)")
|
|
})
|
|
}
|
|
}
|
|
}
|
|
|
|
// MARK: Send Text
|
|
|
|
messageToolbar.textSendAction = { [weak self] messageToolbar in
|
|
|
|
let text = messageToolbar.messageTextView.text!.trimming(.WhitespaceAndNewline)
|
|
|
|
self?.cleanTextInput()
|
|
|
|
self?.trySnapContentOfConversationCollectionViewToBottom()
|
|
|
|
if text.isEmpty {
|
|
return
|
|
}
|
|
|
|
if let withFriend = self?.conversation.withFriend {
|
|
|
|
sendText(text, toRecipient: withFriend.userID, recipientType: "User", afterCreatedMessage: { [weak self] message in
|
|
|
|
dispatch_async(dispatch_get_main_queue()) {
|
|
self?.updateConversationCollectionViewWithMessageIDs(nil, messageAge: .New, scrollToBottom: true, success: { _ in
|
|
})
|
|
}
|
|
|
|
}, failureHandler: { [weak self] reason, errorMessage in
|
|
defaultFailureHandler(reason, errorMessage: errorMessage)
|
|
|
|
YepAlert.alertSorry(message: NSLocalizedString("Failed to send text!\nTry tap on message to resend.", comment: ""), inViewController: self)
|
|
|
|
}, completion: { success in
|
|
println("sendText to friend: \(success)")
|
|
|
|
// 发送过消息后才提示加好友
|
|
dispatch_async(dispatch_get_main_queue()) { [weak self] in
|
|
if let strongSelf = self {
|
|
if !strongSelf.isTryingShowFriendRequestView {
|
|
strongSelf.isTryingShowFriendRequestView = true
|
|
strongSelf.tryShowFriendRequestView()
|
|
}
|
|
}
|
|
}
|
|
})
|
|
|
|
} else if let withGroup = self?.conversation.withGroup {
|
|
|
|
sendText(text, toRecipient: withGroup.groupID, recipientType: "Circle", afterCreatedMessage: { [weak self] message in
|
|
|
|
dispatch_async(dispatch_get_main_queue()) {
|
|
self?.updateConversationCollectionViewWithMessageIDs(nil, messageAge: .New, scrollToBottom: true, success: { _ in
|
|
})
|
|
}
|
|
|
|
}, failureHandler: { [weak self] reason, errorMessage in
|
|
defaultFailureHandler(reason, errorMessage: errorMessage)
|
|
|
|
dispatch_async(dispatch_get_main_queue()) {
|
|
YepAlert.alertSorry(message: NSLocalizedString("Failed to send text!\nTry tap on message to resend.", comment: ""), inViewController: self)
|
|
}
|
|
|
|
}, completion: { success in
|
|
println("sendText to group: \(success)")
|
|
})
|
|
}
|
|
}
|
|
|
|
// MARK: Send Audio
|
|
|
|
let hideWaver: () -> Void = { [weak self] in
|
|
self?.swipeUpView.hidden = true
|
|
self?.waverView.removeFromSuperview()
|
|
}
|
|
|
|
let sendAudioMessage: () -> Void = { [weak self] in
|
|
// Prepare meta data
|
|
|
|
var metaData: String? = nil
|
|
|
|
if let audioSamples = self?.waverView.waver.compressSamples() {
|
|
|
|
var audioSamples = audioSamples
|
|
// 浮点数最多两位小数，使下面计算 metaData 时不至于太长
|
|
for i in 0..<audioSamples.count {
|
|
var sample = audioSamples[i]
|
|
sample = round(sample * 100.0) / 100.0
|
|
audioSamples[i] = sample
|
|
}
|
|
|
|
if let fileURL = YepAudioService.sharedManager.audioFileURL {
|
|
let audioAsset = AVURLAsset(URL: fileURL, options: nil)
|
|
let audioDuration = CMTimeGetSeconds(audioAsset.duration) as Double
|
|
|
|
println("\nComporessed \(audioSamples)")
|
|
|
|
let audioMetaDataInfo = [YepConfig.MetaData.audioSamples: audioSamples, YepConfig.MetaData.audioDuration: audioDuration]
|
|
|
|
if let audioMetaData = try? NSJSONSerialization.dataWithJSONObject(audioMetaDataInfo, options: []) {
|
|
let audioMetaDataString = NSString(data: audioMetaData, encoding: NSUTF8StringEncoding) as? String
|
|
metaData = audioMetaDataString
|
|
}
|
|
}
|
|
}
|
|
|
|
// Do send
|
|
|
|
if let fileURL = YepAudioService.sharedManager.audioFileURL {
|
|
if let withFriend = self?.conversation.withFriend {
|
|
sendAudioInFilePath(fileURL.path!, orFileData: nil, metaData: metaData, toRecipient: withFriend.userID, recipientType: "User", afterCreatedMessage: { [weak self] message in
|
|
|
|
dispatch_async(dispatch_get_main_queue()) {
|
|
if let realm = message.realm {
|
|
let _ = try? realm.write {
|
|
message.localAttachmentName = fileURL.URLByDeletingPathExtension?.lastPathComponent ?? ""
|
|
message.mediaType = MessageMediaType.Audio.rawValue
|
|
if let metaDataString = metaData {
|
|
message.mediaMetaData = mediaMetaDataFromString(metaDataString, inRealm: realm)
|
|
}
|
|
}
|
|
|
|
self?.updateConversationCollectionViewWithMessageIDs(nil, messageAge: .New, scrollToBottom: true, success: { _ in
|
|
})
|
|
}
|
|
}
|
|
|
|
}, failureHandler: { [weak self] reason, errorMessage in
|
|
defaultFailureHandler(reason, errorMessage: errorMessage)
|
|
|
|
YepAlert.alertSorry(message: NSLocalizedString("Failed to send audio!\nTry tap on message to resend.", comment: ""), inViewController: self)
|
|
|
|
}, completion: { success in
|
|
println("send audio to friend: \(success)")
|
|
})
|
|
|
|
} else if let withGroup = self?.conversation.withGroup {
|
|
sendAudioInFilePath(fileURL.path!, orFileData: nil, metaData: metaData, toRecipient: withGroup.groupID, recipientType: "Circle", afterCreatedMessage: { [weak self] message in
|
|
|
|
dispatch_async(dispatch_get_main_queue()) {
|
|
if let realm = message.realm {
|
|
let _ = try? realm.write {
|
|
message.localAttachmentName = fileURL.URLByDeletingPathExtension?.lastPathComponent ?? ""
|
|
message.mediaType = MessageMediaType.Audio.rawValue
|
|
if let metaDataString = metaData {
|
|
message.mediaMetaData = mediaMetaDataFromString(metaDataString, inRealm: realm)
|
|
}
|
|
}
|
|
|
|
self?.updateConversationCollectionViewWithMessageIDs(nil, messageAge: .New, scrollToBottom: true, success: { _ in
|
|
})
|
|
}
|
|
}
|
|
|
|
}, failureHandler: { [weak self] reason, errorMessage in
|
|
defaultFailureHandler(reason, errorMessage: errorMessage)
|
|
|
|
YepAlert.alertSorry(message: NSLocalizedString("Failed to send audio!\nTry tap on message to resend.", comment: ""), inViewController: self)
|
|
|
|
}, completion: { success in
|
|
println("send audio to group: \(success)")
|
|
})
|
|
}
|
|
}
|
|
}
|
|
|
|
// MARK: Voice Record
|
|
|
|
messageToolbar.voiceRecordBeginAction = { [weak self] messageToolbar in
|
|
|
|
YepAudioService.sharedManager.shouldIgnoreStart = false
|
|
|
|
if let strongSelf = self {
|
|
|
|
strongSelf.view.addSubview(strongSelf.waverView)
|
|
|
|
strongSelf.swipeUpPromptLabel.text = NSLocalizedString("Swipe Up to Cancel", comment: "")
|
|
strongSelf.swipeUpView.hidden = false
|
|
strongSelf.view.bringSubviewToFront(strongSelf.swipeUpView)
|
|
strongSelf.view.bringSubviewToFront(strongSelf.messageToolbar)
|
|
strongSelf.view.bringSubviewToFront(strongSelf.moreMessageTypesView)
|
|
|
|
let audioFileName = NSUUID().UUIDString
|
|
|
|
strongSelf.waverView.waver.resetWaveSamples()
|
|
strongSelf.samplesCount = 0
|
|
|
|
if let fileURL = NSFileManager.yepMessageAudioURLWithName(audioFileName) {
|
|
|
|
YepAudioService.sharedManager.beginRecordWithFileURL(fileURL, audioRecorderDelegate: strongSelf)
|
|
|
|
YepAudioService.sharedManager.recordTimeoutAction = {
|
|
|
|
hideWaver()
|
|
|
|
sendAudioMessage()
|
|
}
|
|
|
|
YepAudioService.sharedManager.startCheckRecordTimeoutTimer()
|
|
}
|
|
|
|
if let withFriend = strongSelf.conversation.withFriend {
|
|
|
|
let typingMessage: JSONDictionary = ["state": FayeService.InstantStateType.Audio.rawValue]
|
|
|
|
if FayeService.sharedManager.client.connected {
|
|
FayeService.sharedManager.sendPrivateMessage(typingMessage, messageType: .Instant, userID: withFriend.userID, completion: { (result, messageID) in
|
|
println("Send recording \(result)")
|
|
})
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
messageToolbar.voiceRecordEndAction = { messageToolbar in
|
|
|
|
YepAudioService.sharedManager.shouldIgnoreStart = true
|
|
|
|
hideWaver()
|
|
|
|
let interruptAudioRecord: () -> Void = {
|
|
YepAudioService.sharedManager.endRecord()
|
|
YepAudioService.sharedManager.recordTimeoutAction = nil
|
|
}
|
|
|
|
// 小于 0.5 秒不创建消息
|
|
if YepAudioService.sharedManager.audioRecorder?.currentTime < YepConfig.AudioRecord.shortestDuration {
|
|
|
|
interruptAudioRecord()
|
|
return
|
|
}
|
|
|
|
interruptAudioRecord()
|
|
|
|
sendAudioMessage()
|
|
}
|
|
|
|
messageToolbar.voiceRecordCancelAction = { [weak self] messageToolbar in
|
|
|
|
self?.swipeUpView.hidden = true
|
|
self?.waverView.removeFromSuperview()
|
|
|
|
YepAudioService.sharedManager.endRecord()
|
|
|
|
YepAudioService.sharedManager.recordTimeoutAction = nil
|
|
}
|
|
|
|
messageToolbar.voiceRecordingUpdateUIAction = { [weak self] topOffset in
|
|
|
|
let text: String
|
|
|
|
if topOffset > 40 {
|
|
text = NSLocalizedString("Release to Cancel", comment: "")
|
|
} else {
|
|
text = NSLocalizedString("Swipe Up to Cancel", comment: "")
|
|
}
|
|
|
|
self?.swipeUpPromptLabel.text = text
|
|
}
|
|
}
|
|
}
|
|
|
|
private func batchMarkMessagesAsReaded(updateOlderMessagesIfNeeded updateOlderMessagesIfNeeded: Bool = true) {
|
|
|
|
let _ = try? realm.write { [weak self] in
|
|
self?.conversation.unreadMessagesCount = 0
|
|
}
|
|
|
|
if let recipient = conversation.recipient, latestMessage = messages.last {
|
|
|
|
var needMarkInServer = false
|
|
|
|
if updateOlderMessagesIfNeeded {
|
|
|
|
var predicate = NSPredicate(format: "readed = false", argumentArray: nil)
|
|
|
|
if case .OneToOne = recipient.type {
|
|
predicate = NSPredicate(format: "readed = false AND fromFriend != nil AND fromFriend.friendState != %d", UserFriendState.Me.rawValue)
|
|
}
|
|
|
|
let filteredMessages = messages.filter(predicate)
|
|
|
|
println("filteredMessages.count: \(filteredMessages.count)")
|
|
|
|
needMarkInServer = !filteredMessages.isEmpty
|
|
|
|
filteredMessages.forEach { message in
|
|
let _ = try? realm.write {
|
|
message.readed = true
|
|
}
|
|
}
|
|
|
|
} else {
|
|
let _ = try? realm.write {
|
|
latestMessage.readed = true
|
|
}
|
|
|
|
needMarkInServer = true
|
|
|
|
println("mark latestMessage readed")
|
|
}
|
|
|
|
if needMarkInServer {
|
|
|
|
dispatch_async(dispatch_get_main_queue()) {
|
|
NSNotificationCenter.defaultCenter().postNotificationName(YepConfig.Notification.markAsReaded, object: nil)
|
|
}
|
|
|
|
batchMarkAsReadOfMessagesToRecipient(recipient, beforeMessage: latestMessage, failureHandler: nil, completion: {
|
|
println("batchMarkAsReadOfMessagesToRecipient OK")
|
|
})
|
|
|
|
} else {
|
|
println("don't needMarkInServer")
|
|
}
|
|
}
|
|
}
|
|
|
|
override func viewWillDisappear(animated: Bool) {
|
|
super.viewWillDisappear(animated)
|
|
|
|
if let checkTypingStatusTimer = checkTypingStatusTimer {
|
|
checkTypingStatusTimer.invalidate()
|
|
}
|
|
NSNotificationCenter.defaultCenter().postNotificationName(MessageToolbar.Notification.updateDraft, object: nil)
|
|
}
|
|
|
|
override func viewDidDisappear(animated: Bool) {
|
|
super.viewDidDisappear(animated)
|
|
|
|
FayeService.sharedManager.delegate = nil
|
|
checkTypingStatusTimer?.invalidate()
|
|
checkTypingStatusTimer = nil // 及时释放
|
|
|
|
waverView.removeFromSuperview()
|
|
|
|
// stop audio playing
|
|
|
|
if let audioPlayer = YepAudioService.sharedManager.audioPlayer {
|
|
if audioPlayer.playing {
|
|
audioPlayer.stop()
|
|
}
|
|
}
|
|
}
|
|
|
|
override func viewDidLayoutSubviews() {
|
|
super.viewDidLayoutSubviews()
|
|
|
|
// 初始时移动一次到底部
|
|
if !conversationCollectionViewHasBeenMovedToBottomOnce {
|
|
|
|
// 先调整一下初次的 contentInset
|
|
setConversaitonCollectionViewOriginalContentInset()
|
|
|
|
// 尽量滚到底部
|
|
tryScrollToBottom()
|
|
}
|
|
}
|
|
|
|
// MARK: UI
|
|
|
|
func tryShowFriendRequestView() {
|
|
|
|
if let user = conversation.withFriend {
|
|
|
|
// 若是陌生人或还未收到回应才显示 FriendRequestView
|
|
if user.friendState != UserFriendState.Stranger.rawValue && user.friendState != UserFriendState.IssuedRequest.rawValue {
|
|
return
|
|
}
|
|
|
|
let userID = user.userID
|
|
let userNickname = user.nickname
|
|
|
|
stateOfFriendRequestWithUser(user, failureHandler: { reason, errorMessage in
|
|
defaultFailureHandler(reason, errorMessage: errorMessage)
|
|
|
|
}, completion: { isFriend, receivedFriendRequestState, receivedFriendRequestID, sentFriendRequestState in
|
|
|
|
println("isFriend: \(isFriend)")
|
|
println("receivedFriendRequestState: \(receivedFriendRequestState.rawValue)")
|
|
println("receivedFriendRequestID: \(receivedFriendRequestID)")
|
|
println("sentFriendRequestState: \(sentFriendRequestState.rawValue)")
|
|
|
|
// 已是好友下面就不用处理了
|
|
if isFriend {
|
|
return
|
|
}
|
|
|
|
dispatch_async(dispatch_get_main_queue()) { [weak self] in
|
|
|
|
if receivedFriendRequestState == .Pending {
|
|
self?.makeFriendRequestViewWithUser(user, state: .Consider(prompt: NSLocalizedString("try add you as friend.", comment: ""), friendRequestID: receivedFriendRequestID))
|
|
|
|
} else if receivedFriendRequestState == .Blocked {
|
|
YepAlert.confirmOrCancel(title: NSLocalizedString("Notice", comment: ""), message: String(format: NSLocalizedString("You have blocked %@! Do you want to unblock him or her?", comment: ""), "\(userNickname)")
|
|
, confirmTitle: NSLocalizedString("Unblock", comment: ""), cancelTitle: NSLocalizedString("Not now", comment: ""), inViewController: self, withConfirmAction: {
|
|
|
|
unblockUserWithUserID(userID, failureHandler: nil, completion: { success in
|
|
println("unblockUserWithUserID \(success)")
|
|
|
|
self?.updateBlocked(false, forUserWithUserID: userID, needUpdateUI: false)
|
|
})
|
|
|
|
}, cancelAction: {
|
|
})
|
|
|
|
} else {
|
|
if sentFriendRequestState == .None {
|
|
if receivedFriendRequestState != .Rejected && receivedFriendRequestState != .Blocked {
|
|
self?.makeFriendRequestViewWithUser(user, state: .Add(prompt: NSLocalizedString("is not your friend.", comment: "")))
|
|
}
|
|
|
|
} else if sentFriendRequestState == .Rejected {
|
|
self?.makeFriendRequestViewWithUser(user, state: .Add(prompt: NSLocalizedString("reject your last friend request.", comment: "")))
|
|
|
|
} else if sentFriendRequestState == .Blocked {
|
|
YepAlert.alertSorry(message: String(format: NSLocalizedString("You have been blocked by %@!", comment: ""), "\(userNickname)"), inViewController: self)
|
|
}
|
|
}
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func makeFriendRequestViewWithUser(user: User, state: FriendRequestView.State) {
|
|
|
|
let friendRequestView = FriendRequestView(state: state)
|
|
|
|
friendRequestView.translatesAutoresizingMaskIntoConstraints = false
|
|
view.addSubview(friendRequestView)
|
|
|
|
let friendRequestViewLeading = NSLayoutConstraint(item: friendRequestView, attribute: .Leading, relatedBy: .Equal, toItem: view, attribute: .Leading, multiplier: 1, constant: 0)
|
|
let friendRequestViewTrailing = NSLayoutConstraint(item: friendRequestView, attribute: .Trailing, relatedBy: .Equal, toItem: view, attribute: .Trailing, multiplier: 1, constant: 0)
|
|
let friendRequestViewTop = NSLayoutConstraint(item: friendRequestView, attribute: .Top, relatedBy: .Equal, toItem: view, attribute: .Top, multiplier: 1, constant: 64 - FriendRequestView.height)
|
|
let friendRequestViewHeight = NSLayoutConstraint(item: friendRequestView, attribute: .Height, relatedBy: .Equal, toItem: nil, attribute: .NotAnAttribute, multiplier: 1, constant: FriendRequestView.height)
|
|
|
|
NSLayoutConstraint.activateConstraints([friendRequestViewLeading, friendRequestViewTrailing, friendRequestViewTop, friendRequestViewHeight])
|
|
|
|
view.layoutIfNeeded()
|
|
UIView.animateWithDuration(0.2, delay: 0.1, options: UIViewAnimationOptions.CurveEaseInOut, animations: { () -> Void in
|
|
self.conversationCollectionView.contentInset.top += FriendRequestView.height
|
|
|
|
friendRequestViewTop.constant += FriendRequestView.height
|
|
self.view.layoutIfNeeded()
|
|
|
|
}, completion: { _ in })
|
|
|
|
friendRequestView.user = user
|
|
|
|
let userID = user.userID
|
|
|
|
let hideFriendRequestView: () -> Void = {
|
|
dispatch_async(dispatch_get_main_queue()) { [weak self] in
|
|
|
|
UIView.animateWithDuration(0.2, delay: 0.1, options: UIViewAnimationOptions.CurveEaseInOut, animations: {
|
|
if let strongSelf = self {
|
|
strongSelf.conversationCollectionView.contentInset.top = 64 + strongSelf.conversationCollectionViewContentInsetYOffset
|
|
|
|
friendRequestViewTop.constant -= FriendRequestView.height
|
|
strongSelf.view.layoutIfNeeded()
|
|
}
|
|
|
|
}, completion: { _ in
|
|
friendRequestView.removeFromSuperview()
|
|
|
|
if let strongSelf = self {
|
|
strongSelf.isTryingShowFriendRequestView = false
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
friendRequestView.addAction = { [weak self] friendRequestView in
|
|
println("try Send Friend Request")
|
|
|
|
sendFriendRequestToUser(user, failureHandler: { [weak self] reason, errorMessage in
|
|
YepAlert.alertSorry(message: NSLocalizedString("Send Friend Request failed!", comment: ""), inViewController: self)
|
|
|
|
}, completion: { friendRequestState in
|
|
println("friendRequestState: \(friendRequestState.rawValue)")
|
|
|
|
dispatch_async(dispatch_get_main_queue()) {
|
|
guard let realm = try? Realm() else {
|
|
return
|
|
}
|
|
if let user = userWithUserID(userID, inRealm: realm) {
|
|
let _ = try? realm.write {
|
|
user.friendState = UserFriendState.IssuedRequest.rawValue
|
|
}
|
|
}
|
|
}
|
|
|
|
hideFriendRequestView()
|
|
})
|
|
}
|
|
|
|
friendRequestView.acceptAction = { [weak self] friendRequestView in
|
|
println("friendRequestView.acceptAction")
|
|
|
|
if let friendRequestID = friendRequestView.state.friendRequestID {
|
|
|
|
acceptFriendRequestWithID(friendRequestID, failureHandler: { [weak self] reason, errorMessage in
|
|
YepAlert.alertSorry(message: NSLocalizedString("Accept Friend Request failed!", comment: ""), inViewController: self)
|
|
|
|
}, completion: { success in
|
|
println("acceptFriendRequestWithID: \(friendRequestID), \(success)")
|
|
|
|
dispatch_async(dispatch_get_main_queue()) {
|
|
guard let realm = try? Realm() else {
|
|
return
|
|
}
|
|
if let user = userWithUserID(userID, inRealm: realm) {
|
|
let _ = try? realm.write {
|
|
user.friendState = UserFriendState.Normal.rawValue
|
|
}
|
|
}
|
|
}
|
|
|
|
hideFriendRequestView()
|
|
})
|
|
|
|
} else {
|
|
println("NOT friendRequestID for acceptFriendRequestWithID")
|
|
}
|
|
}
|
|
|
|
friendRequestView.rejectAction = { [weak self] friendRequestView in
|
|
println("friendRequestView.rejectAction")
|
|
|
|
let confirmAction: () -> Void = {
|
|
|
|
if let friendRequestID = friendRequestView.state.friendRequestID {
|
|
|
|
rejectFriendRequestWithID(friendRequestID, failureHandler: { [weak self] reason, errorMessage in
|
|
YepAlert.alertSorry(message: NSLocalizedString("Reject Friend Request failed!", comment: ""), inViewController: self)
|
|
|
|
}, completion: { success in
|
|
println("rejectFriendRequestWithID: \(friendRequestID), \(success)")
|
|
|
|
hideFriendRequestView()
|
|
})
|
|
|
|
} else {
|
|
println("NOT friendRequestID for rejectFriendRequestWithID")
|
|
}
|
|
}
|
|
|
|
YepAlert.confirmOrCancel(title: NSLocalizedString("Notice", comment: ""), message: NSLocalizedString("Do you want to reject this friend request?", comment: "")
|
|
, confirmTitle: NSLocalizedString("Reject", comment: ""), cancelTitle: NSLocalizedString("Cancel", comment: ""), inViewController: self, withConfirmAction:confirmAction, cancelAction: {
|
|
})
|
|
}
|
|
}
|
|
|
|
private func makeFeedViewWithFeed(feed: ConversationFeed) {
|
|
|
|
let feedView = FeedView.instanceFromNib()
|
|
|
|
feedView.feed = feed
|
|
|
|
feedView.tapAvatarAction = { [weak self] in
|
|
self?.performSegueWithIdentifier("showProfileFromFeedView", sender: nil)
|
|
}
|
|
|
|
feedView.foldAction = { [weak self] in
|
|
if let strongSelf = self {
|
|
UIView.animateWithDuration(0.15, delay: 0.0, options: .CurveEaseInOut, animations: { [weak self] in
|
|
self?.conversationCollectionView.contentInset.top = 64 + FeedView.foldHeight + strongSelf.conversationCollectionViewContentInsetYOffset
|
|
}, completion: { _ in })
|
|
}
|
|
}
|
|
|
|
feedView.unfoldAction = { [weak self] feedView in
|
|
if let strongSelf = self {
|
|
UIView.animateWithDuration(0.15, delay: 0.0, options: .CurveEaseInOut, animations: { [weak self] in
|
|
self?.conversationCollectionView.contentInset.top = 64 + feedView.normalHeight + strongSelf.conversationCollectionViewContentInsetYOffset
|
|
}, completion: { _ in })
|
|
}
|
|
}
|
|
|
|
feedView.tapMediaAction = { [weak self] transitionView, image, attachments, index in
|
|
|
|
guard image != nil else {
|
|
return
|
|
}
|
|
|
|
let vc = UIStoryboard(name: "MediaPreview", bundle: nil).instantiateViewControllerWithIdentifier("MediaPreviewViewController") as! MediaPreviewViewController
|
|
|
|
vc.previewMedias = attachments.map({ PreviewMedia.AttachmentType(attachment: $0) })
|
|
vc.startIndex = index
|
|
|
|
let transitionView = transitionView
|
|
let frame = transitionView.convertRect(transitionView.frame, toView: self?.view)
|
|
vc.previewImageViewInitalFrame = frame
|
|
vc.bottomPreviewImage = image
|
|
|
|
self?.view.endEditing(true)
|
|
|
|
delay(0.3, work: { () -> Void in
|
|
transitionView.alpha = 0 // 加 Delay 避免图片闪烁
|
|
})
|
|
|
|
vc.afterDismissAction = { [weak self] in
|
|
transitionView.alpha = 1
|
|
self?.view.window?.makeKeyAndVisible()
|
|
}
|
|
|
|
mediaPreviewWindow.rootViewController = vc
|
|
mediaPreviewWindow.windowLevel = UIWindowLevelAlert - 1
|
|
mediaPreviewWindow.makeKeyAndVisible()
|
|
|
|
/*
|
|
let info = [
|
|
"transitionView": transitionView,
|
|
"attachments": Box(value: attachments),
|
|
"index": index,
|
|
]
|
|
self?.performSegueWithIdentifier("showFeedMedia", sender: info)
|
|
*/
|
|
}
|
|
|
|
//feedView.backgroundColor = UIColor.orangeColor()
|
|
feedView.translatesAutoresizingMaskIntoConstraints = false
|
|
|
|
view.addSubview(feedView)
|
|
|
|
let views = [
|
|
"feedView": feedView
|
|
]
|
|
|
|
let constraintsH = NSLayoutConstraint.constraintsWithVisualFormat("H:|[feedView]|", options: NSLayoutFormatOptions(rawValue: 0), metrics: nil, views: views)
|
|
|
|
let top = NSLayoutConstraint(item: feedView, attribute: .Top, relatedBy: .Equal, toItem: view, attribute: .Top, multiplier: 1.0, constant: 64)
|
|
let height = NSLayoutConstraint(item: feedView, attribute: .Height, relatedBy: .Equal, toItem: nil, attribute: .NotAnAttribute, multiplier: 1.0, constant: feedView.normalHeight)
|
|
|
|
NSLayoutConstraint.activateConstraints(constraintsH)
|
|
//NSLayoutConstraint.activateConstraints(constraintsV)
|
|
NSLayoutConstraint.activateConstraints([top, height])
|
|
|
|
feedView.heightConstraint = height
|
|
|
|
self.feedView = feedView
|
|
}
|
|
|
|
private func trySnapContentOfConversationCollectionViewToBottom(forceAnimation forceAnimation: Bool = false) {
|
|
|
|
///// Provent form unwanted scrolling
|
|
if let lastToolbarFrame = messageToolbar.lastToolbarFrame {
|
|
if lastToolbarFrame == messageToolbar.frame {
|
|
return
|
|
} else {
|
|
messageToolbar.lastToolbarFrame = messageToolbar.frame
|
|
}
|
|
} else {
|
|
messageToolbar.lastToolbarFrame = messageToolbar.frame
|
|
}
|
|
/////
|
|
|
|
let newContentOffsetY = conversationCollectionView.contentSize.height - messageToolbar.frame.origin.y
|
|
|
|
let bottom = view.bounds.height - messageToolbar.frame.origin.y
|
|
|
|
guard newContentOffsetY + conversationCollectionView.contentInset.top > 0 else {
|
|
|
|
UIView.animateWithDuration(0.1, delay: 0.0, options: .CurveEaseInOut, animations: { [weak self] in
|
|
if let strongSelf = self {
|
|
strongSelf.conversationCollectionView.contentInset.bottom = bottom
|
|
}
|
|
}, completion: { _ in })
|
|
|
|
return
|
|
}
|
|
|
|
var needDoAnimation = forceAnimation
|
|
|
|
let bottomInsetOffset = bottom - conversationCollectionView.contentInset.bottom
|
|
|
|
if bottomInsetOffset != 0 {
|
|
needDoAnimation = true
|
|
}
|
|
|
|
if conversationCollectionView.contentOffset.y != newContentOffsetY {
|
|
needDoAnimation = true
|
|
}
|
|
|
|
guard needDoAnimation else {
|
|
return
|
|
}
|
|
|
|
UIView.animateWithDuration(forceAnimation ? 0.25 : 0.1, delay: 0.0, options: .CurveEaseInOut, animations: { [weak self] in
|
|
if let strongSelf = self {
|
|
strongSelf.conversationCollectionView.contentInset.bottom = bottom
|
|
strongSelf.conversationCollectionView.contentOffset.y = newContentOffsetY
|
|
}
|
|
}, completion: { _ in })
|
|
}
|
|
|
|
// MARK: Private
|
|
|
|
private func setConversaitonCollectionViewContentInsetBottom(bottom: CGFloat) {
|
|
var contentInset = conversationCollectionView.contentInset
|
|
contentInset.bottom = bottom
|
|
conversationCollectionView.contentInset = contentInset
|
|
}
|
|
|
|
private func setConversaitonCollectionViewOriginalContentInset() {
|
|
|
|
let feedViewHeight: CGFloat = (feedView == nil) ? 0 : feedView!.height
|
|
conversationCollectionView.contentInset.top = 64 + feedViewHeight + conversationCollectionViewContentInsetYOffset
|
|
|
|
setConversaitonCollectionViewContentInsetBottom(CGRectGetHeight(messageToolbar.bounds) + sectionInsetBottom)
|
|
}
|
|
|
|
private var messageHeights = [String: CGFloat]()
|
|
private func heightOfMessage(message: Message) -> CGFloat {
|
|
|
|
let key = message.messageID
|
|
|
|
if !key.isEmpty {
|
|
if let messageHeight = messageHeights[key] {
|
|
return messageHeight
|
|
}
|
|
}
|
|
|
|
var height: CGFloat = 0
|
|
|
|
switch message.mediaType {
|
|
|
|
case MessageMediaType.Text.rawValue:
|
|
let rect = message.textContent.boundingRectWithSize(CGSize(width: messageTextLabelMaxWidth, height: CGFloat(FLT_MAX)), options: [.UsesLineFragmentOrigin, .UsesFontLeading], attributes: YepConfig.ChatCell.textAttributes, context: nil)
|
|
|
|
height = max(ceil(rect.height) + (11 * 2), YepConfig.chatCellAvatarSize())
|
|
|
|
if !key.isEmpty {
|
|
textContentLabelWidths[key] = ceil(rect.width)
|
|
}
|
|
|
|
case MessageMediaType.Image.rawValue:
|
|
|
|
if let (imageWidth, imageHeight) = imageMetaOfMessage(message) {
|
|
|
|
let aspectRatio = imageWidth / imageHeight
|
|
|
|
if aspectRatio >= 1 {
|
|
height = max(ceil(messageImagePreferredWidth / aspectRatio), YepConfig.ChatCell.mediaMinHeight)
|
|
} else {
|
|
height = max(messageImagePreferredHeight, ceil(YepConfig.ChatCell.mediaMinWidth / aspectRatio))
|
|
}
|
|
|
|
} else {
|
|
height = ceil(messageImagePreferredWidth / messageImagePreferredAspectRatio)
|
|
}
|
|
|
|
case MessageMediaType.Audio.rawValue:
|
|
height = 40
|
|
|
|
case MessageMediaType.Video.rawValue:
|
|
|
|
if let (videoWidth, videoHeight) = videoMetaOfMessage(message) {
|
|
|
|
let aspectRatio = videoWidth / videoHeight
|
|
|
|
if aspectRatio >= 1 {
|
|
height = max(ceil(messageImagePreferredWidth / aspectRatio), YepConfig.ChatCell.mediaMinHeight)
|
|
} else {
|
|
height = max(messageImagePreferredHeight, ceil(YepConfig.ChatCell.mediaMinWidth / aspectRatio))
|
|
}
|
|
|
|
} else {
|
|
height = ceil(messageImagePreferredWidth / messageImagePreferredAspectRatio)
|
|
}
|
|
|
|
case MessageMediaType.Location.rawValue:
|
|
height = 108
|
|
|
|
case MessageMediaType.SectionDate.rawValue:
|
|
height = 20
|
|
|
|
case MessageMediaType.SocialWork.rawValue:
|
|
height = 135
|
|
|
|
default:
|
|
height = 20
|
|
}
|
|
|
|
if message.mediaType != MessageMediaType.SectionDate.rawValue && conversation.withGroup != nil {
|
|
|
|
if let sender = message.fromFriend {
|
|
if sender.friendState != UserFriendState.Me.rawValue {
|
|
height += YepConfig.ChatCell.marginTopForGroup
|
|
}
|
|
}
|
|
}
|
|
|
|
if !key.isEmpty {
|
|
messageHeights[key] = height
|
|
}
|
|
|
|
return height
|
|
}
|
|
|
|
private var textContentLabelWidths = [String: CGFloat]()
|
|
private func textContentLabelWidthOfMessage(message: Message) -> CGFloat {
|
|
let key = message.messageID
|
|
|
|
if !key.isEmpty {
|
|
if let textContentLabelWidth = textContentLabelWidths[key] {
|
|
return textContentLabelWidth
|
|
}
|
|
}
|
|
|
|
let rect = message.textContent.boundingRectWithSize(CGSize(width: messageTextLabelMaxWidth, height: CGFloat(FLT_MAX)), options: [.UsesLineFragmentOrigin, .UsesFontLeading], attributes: YepConfig.ChatCell.textAttributes, context: nil)
|
|
|
|
let width = ceil(rect.width)
|
|
|
|
if !key.isEmpty {
|
|
textContentLabelWidths[key] = width
|
|
}
|
|
|
|
return width
|
|
}
|
|
|
|
private var audioPlayedDurations = [String: Double]()
|
|
|
|
private func audioPlayedDurationOfMessage(message: Message) -> Double {
|
|
let key = message.messageID
|
|
|
|
if !key.isEmpty {
|
|
if let playedDuration = audioPlayedDurations[key] {
|
|
return playedDuration
|
|
}
|
|
}
|
|
|
|
return 0
|
|
}
|
|
|
|
private func setAudioPlayedDuration(audioPlayedDuration: Double, ofMessage message: Message) {
|
|
let key = message.messageID
|
|
if !key.isEmpty {
|
|
audioPlayedDurations[key] = audioPlayedDuration
|
|
}
|
|
|
|
// recover audio cells' UI
|
|
|
|
if audioPlayedDuration == 0 {
|
|
|
|
if let sender = message.fromFriend, index = messages.indexOf(message) {
|
|
|
|
let indexPath = NSIndexPath(forItem: index - displayedMessagesRange.location, inSection: 0)
|
|
|
|
if sender.friendState != UserFriendState.Me.rawValue { // from Friend
|
|
if let cell = conversationCollectionView.cellForItemAtIndexPath(indexPath) as? ChatLeftAudioCell {
|
|
cell.audioPlayedDuration = 0
|
|
}
|
|
|
|
} else {
|
|
if let cell = conversationCollectionView.cellForItemAtIndexPath(indexPath) as? ChatRightAudioCell {
|
|
cell.audioPlayedDuration = 0
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
func updateAudioPlaybackProgress(timer: NSTimer) {
|
|
|
|
func updateAudioCellOfMessage(message: Message, withCurrentTime currentTime: NSTimeInterval) {
|
|
|
|
if let messageIndex = messages.indexOf(message) {
|
|
|
|
let indexPath = NSIndexPath(forItem: messageIndex - displayedMessagesRange.location, inSection: 0)
|
|
|
|
if let sender = message.fromFriend {
|
|
if sender.friendState != UserFriendState.Me.rawValue {
|
|
if let cell = conversationCollectionView.cellForItemAtIndexPath(indexPath) as? ChatLeftAudioCell {
|
|
cell.audioPlayedDuration = currentTime
|
|
}
|
|
|
|
} else {
|
|
if let cell = conversationCollectionView.cellForItemAtIndexPath(indexPath) as? ChatRightAudioCell {
|
|
cell.audioPlayedDuration = currentTime
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if let audioPlayer = YepAudioService.sharedManager.audioPlayer {
|
|
|
|
if let playingMessage = YepAudioService.sharedManager.playingMessage {
|
|
|
|
let currentTime = audioPlayer.currentTime
|
|
|
|
setAudioPlayedDuration(currentTime, ofMessage: playingMessage)
|
|
|
|
updateAudioCellOfMessage(playingMessage, withCurrentTime: currentTime)
|
|
}
|
|
}
|
|
}
|
|
|
|
private func tryFoldFeedView() {
|
|
|
|
guard let feedView = feedView else {
|
|
return
|
|
}
|
|
|
|
if feedView.foldProgress != 1.0 {
|
|
|
|
feedView.foldProgress = 1.0
|
|
}
|
|
}
|
|
|
|
private func syncMessagesReadStatus() {
|
|
|
|
if let recipient = conversation.recipient {
|
|
lastMessageReadUnixTimeByRecipient(recipient, failureHandler: nil, completion: { [weak self] lastReadUnixTime in
|
|
|
|
if let lastReadUnixTime = lastReadUnixTime {
|
|
self?.markAsReadAllSentMesagesBeforeUnixTime(lastReadUnixTime)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
private func markAsReadAllSentMesagesBeforeUnixTime(unixTime: NSTimeInterval) {
|
|
|
|
dispatch_async(dispatch_get_main_queue()) { [weak self] in
|
|
|
|
guard let recipient = self?.conversation.recipient else {
|
|
return
|
|
}
|
|
|
|
dispatch_async(realmQueue) {
|
|
|
|
guard let realm = try? Realm(), conversation = recipient.conversationInRealm(realm) else {
|
|
return
|
|
}
|
|
|
|
let predicate = NSPredicate(format: "readed = false AND fromFriend != nil AND fromFriend.friendState = %d AND createdUnixTime <= %lf", UserFriendState.Me.rawValue, unixTime + 1) // TODO: Time offset
|
|
|
|
let unreadMessages = messagesOfConversation(conversation, inRealm: realm).filter(predicate)
|
|
|
|
let _ = try? realm.write {
|
|
unreadMessages.forEach {
|
|
|
|
$0.readed = true
|
|
$0.sendState = MessageSendState.Read.rawValue
|
|
}
|
|
}
|
|
|
|
delay(0.5, work: {
|
|
NSNotificationCenter.defaultCenter().postNotificationName(MessageNotification.MessageStateChanged, object: nil)
|
|
})
|
|
}
|
|
}
|
|
}
|
|
|
|
// MARK: Actions
|
|
|
|
func messagesMarkAsReadByRecipient(notifictaion: NSNotification) {
|
|
|
|
guard let
|
|
messageDataInfo = notifictaion.object as? [String: AnyObject],
|
|
lastReadUnixTime = messageDataInfo["last_read_at"] as? NSTimeInterval,
|
|
recipientType = messageDataInfo["recipient_type"] as? String,
|
|
recipientID = messageDataInfo["recipient_id"] as? String else {
|
|
return
|
|
}
|
|
|
|
if recipientID == conversation.recipient?.ID && recipientType == conversation.recipient?.type.nameForServer {
|
|
self.markAsReadAllSentMesagesBeforeUnixTime(lastReadUnixTime)
|
|
}
|
|
}
|
|
|
|
func tapToCollapseMessageToolBar(sender: UITapGestureRecognizer) {
|
|
if selectedIndexPathForMenu == nil {
|
|
if messageToolbar.state != .VoiceRecord {
|
|
messageToolbar.state = .Default
|
|
}
|
|
}
|
|
}
|
|
|
|
func checkTypingStatus() {
|
|
|
|
typingResetDelay = typingResetDelay - 0.5
|
|
|
|
if typingResetDelay < 0 {
|
|
self.updateStateInfoOfTitleView(titleView)
|
|
}
|
|
}
|
|
|
|
func tryScrollToBottom() {
|
|
|
|
if displayedMessagesRange.length > 0 {
|
|
|
|
let messageToolBarTop = messageToolbarBottomConstraint.constant + CGRectGetHeight(messageToolbar.bounds)
|
|
|
|
let feedViewHeight: CGFloat = (feedView == nil) ? 0 : feedView!.height
|
|
let invisibleHeight = messageToolBarTop + topBarsHeight + feedViewHeight
|
|
let visibleHeight = conversationCollectionView.frame.height - invisibleHeight
|
|
|
|
let canScroll = visibleHeight <= conversationCollectionView.contentSize.height
|
|
|
|
if canScroll {
|
|
conversationCollectionView.contentOffset.y = conversationCollectionView.contentSize.height - conversationCollectionView.frame.size.height + messageToolBarTop
|
|
conversationCollectionView.contentInset.bottom = messageToolBarTop
|
|
}
|
|
}
|
|
}
|
|
|
|
func moreAction() {
|
|
|
|
messageToolbar.state = .Default
|
|
|
|
if let _ = conversation?.withFriend {
|
|
moreView.type = .OneToOne
|
|
|
|
oneToOneMoreAction()
|
|
|
|
} else {
|
|
moreView.type = .Topic
|
|
|
|
topicMoreAction()
|
|
}
|
|
}
|
|
|
|
private func topicMoreAction() {
|
|
|
|
let descriotion = conversation.withGroup?.withFeed?.body
|
|
guard let groupID = conversation.withGroup?.groupID else {
|
|
return
|
|
}
|
|
|
|
if let group = conversation.withGroup {
|
|
moreView.notificationEnabled = group.notificationEnabled
|
|
|
|
settingsForCircleWithCircleID(groupID, failureHandler: nil, completion: { [weak self] doNotDisturb in
|
|
self?.updateNotificationEnabled(!doNotDisturb, forGroupWithGroupID: groupID)
|
|
})
|
|
}
|
|
|
|
moreView.toggleDoNotDisturbAction = { [weak self] in
|
|
self?.toggleDoNotDisturb()
|
|
}
|
|
|
|
moreView.unsubscribeAction = { [weak self] in
|
|
|
|
let doDeleteConversation: () -> Void = {
|
|
|
|
dispatch_async(dispatch_get_main_queue()) { [weak self] in
|
|
if let checkTypingStatusTimer = self?.checkTypingStatusTimer {
|
|
checkTypingStatusTimer.invalidate()
|
|
}
|
|
|
|
guard let conversation = self?.conversation, realm = conversation.realm else {
|
|
return
|
|
}
|
|
|
|
deleteConversation(conversation, inRealm: realm)
|
|
|
|
NSNotificationCenter.defaultCenter().postNotificationName(YepConfig.Notification.changedConversation, object: nil)
|
|
|
|
self?.afterDeletedConversationAction?()
|
|
|
|
self?.navigationController?.popViewControllerAnimated(true)
|
|
}
|
|
}
|
|
|
|
guard let feed = self?.conversation.withGroup?.withFeed, feedCreator = feed.creator else {
|
|
return
|
|
}
|
|
|
|
let feedID = feed.feedID
|
|
let feedCreatorID = feedCreator.userID
|
|
|
|
// 若是创建者，再询问是否删除 Feed
|
|
|
|
if feedCreatorID == YepUserDefaults.userID.value {
|
|
|
|
YepAlert.confirmOrCancel(title: NSLocalizedString("Delete", comment: ""), message: NSLocalizedString("Also delete this feed?", comment: ""), confirmTitle: NSLocalizedString("Delete", comment: ""), cancelTitle: NSLocalizedString("Not now", comment: ""), inViewController: self, withConfirmAction: {
|
|
|
|
doDeleteConversation()
|
|
|
|
deleteFeedWithFeedID(feedID, failureHandler: nil, completion: {
|
|
println("deleted feed: \(feedID)")
|
|
})
|
|
|
|
}, cancelAction: {
|
|
doDeleteConversation()
|
|
})
|
|
|
|
} else {
|
|
doDeleteConversation()
|
|
}
|
|
}
|
|
|
|
moreView.shareAction = { [weak self] in
|
|
|
|
guard let descriotion = descriotion else {
|
|
return
|
|
}
|
|
|
|
guard let groupShareURLString = self?.groupShareURLString else {
|
|
|
|
shareURLStringOfGroupWithGroupID(groupID, failureHandler: nil, completion: { [weak self] groupShareURLString in
|
|
|
|
self?.groupShareURLString = groupShareURLString
|
|
|
|
dispatch_async(dispatch_get_main_queue()) { [weak self] in
|
|
self?.shareFeedWithDescripion(descriotion, groupShareURLString: groupShareURLString)
|
|
}
|
|
})
|
|
|
|
return
|
|
}
|
|
|
|
self?.shareFeedWithDescripion(descriotion, groupShareURLString: groupShareURLString)
|
|
}
|
|
|
|
if let window = view.window {
|
|
moreView.showInView(window)
|
|
}
|
|
}
|
|
|
|
private func shareFeedWithDescripion(description: String, groupShareURLString: String) {
|
|
|
|
|
|
let info = MonkeyKing.Info(
|
|
title: NSLocalizedString("Join Us", comment: ""),
|
|
description: description,
|
|
thumbnail: feedView?.mediaView.imageView1.image,
|
|
media: .URL(NSURL(string: groupShareURLString)!)
|
|
)
|
|
|
|
let timeLineinfo = MonkeyKing.Info(
|
|
title: "\(NSLocalizedString("Join Us", comment: "")) \(description)",
|
|
description: description,
|
|
thumbnail: feedView?.mediaView.imageView1.image,
|
|
media: .URL(NSURL(string: groupShareURLString)!)
|
|
)
|
|
|
|
let sessionMessage = MonkeyKing.Message.WeChat(.Session(info: info))
|
|
|
|
let weChatSessionActivity = WeChatActivity(
|
|
type: .Session,
|
|
message: sessionMessage,
|
|
finish: { success in
|
|
println("share Feed to WeChat Session success: \(success)")
|
|
}
|
|
)
|
|
|
|
let timelineMessage = MonkeyKing.Message.WeChat(.Timeline(info: timeLineinfo))
|
|
|
|
let weChatTimelineActivity = WeChatActivity(
|
|
type: .Timeline,
|
|
message: timelineMessage,
|
|
finish: { success in
|
|
println("share Feed to WeChat Timeline success: \(success)")
|
|
}
|
|
)
|
|
|
|
let shareText = "\(description) \(groupShareURLString)\n\(NSLocalizedString("From Yep", comment: ""))"
|
|
|
|
let activityViewController = UIActivityViewController(activityItems: [shareText], applicationActivities: [weChatSessionActivity, weChatTimelineActivity])
|
|
|
|
dispatch_async(dispatch_get_main_queue()) { [weak self] in
|
|
self?.presentViewController(activityViewController, animated: true, completion: nil)
|
|
}
|
|
}
|
|
|
|
private func oneToOneMoreAction() {
|
|
|
|
moreView.showProfileAction = { [weak self] in
|
|
self?.performSegueWithIdentifier("showProfile", sender: nil)
|
|
}
|
|
|
|
if let user = conversation.withFriend {
|
|
moreView.notificationEnabled = user.notificationEnabled
|
|
moreView.blocked = user.blocked
|
|
|
|
let userID = user.userID
|
|
|
|
/*
|
|
userInfoOfUserWithUserID(userID, failureHandler: nil, completion: { userInfo in
|
|
//println("userInfoOfUserWithUserID \(userInfo)")
|
|
|
|
if let doNotDisturb = userInfo["do_not_disturb"] as? Bool {
|
|
self.updateNotificationEnabled(!doNotDisturb, forUserWithUserID: userID)
|
|
}
|
|
|
|
if let blocked = userInfo["blocked"] as? Bool {
|
|
self.updateBlocked(blocked, forUserWithUserID: userID)
|
|
}
|
|
|
|
// 对非好友来说，必要
|
|
|
|
updateUserWithUserID(userID, useUserInfo: userInfo)
|
|
})
|
|
*/
|
|
|
|
settingsForUserWithUserID(userID, failureHandler: nil, completion: { [weak self] blocked, doNotDisturb in
|
|
self?.updateNotificationEnabled(!doNotDisturb, forUserWithUserID: userID)
|
|
self?.updateBlocked(blocked, forUserWithUserID: userID)
|
|
})
|
|
}
|
|
|
|
moreView.toggleDoNotDisturbAction = { [weak self] in
|
|
self?.toggleDoNotDisturb()
|
|
}
|
|
|
|
moreView.toggleBlockAction = { [weak self] in
|
|
self?.toggleBlock()
|
|
}
|
|
|
|
moreView.reportAction = { [weak self] in
|
|
self?.tryReport()
|
|
}
|
|
|
|
if let window = view.window {
|
|
moreView.showInView(window)
|
|
}
|
|
}
|
|
|
|
func updateNotificationEnabled(enabled: Bool, forUserWithUserID userID: String) {
|
|
|
|
guard let realm = try? Realm() else {
|
|
return
|
|
}
|
|
|
|
if let user = userWithUserID(userID, inRealm: realm) {
|
|
let _ = try? realm.write {
|
|
user.notificationEnabled = enabled
|
|
}
|
|
|
|
moreView.notificationEnabled = enabled
|
|
}
|
|
}
|
|
|
|
func updateNotificationEnabled(enabled: Bool, forGroupWithGroupID: String) {
|
|
|
|
guard let realm = try? Realm() else {
|
|
return
|
|
}
|
|
|
|
if let group = groupWithGroupID(forGroupWithGroupID, inRealm: realm) {
|
|
let _ = try? realm.write {
|
|
group.notificationEnabled = enabled
|
|
}
|
|
|
|
moreView.notificationEnabled = enabled
|
|
}
|
|
}
|
|
|
|
func toggleDoNotDisturb() {
|
|
|
|
if let user = conversation.withFriend {
|
|
|
|
let userID = user.userID
|
|
|
|
if user.notificationEnabled {
|
|
disableNotificationFromUserWithUserID(userID, failureHandler: nil, completion: { success in
|
|
println("disableNotificationFromUserWithUserID \(success)")
|
|
})
|
|
|
|
updateNotificationEnabled(false, forUserWithUserID: userID)
|
|
|
|
} else {
|
|
enableNotificationFromUserWithUserID(userID, failureHandler: nil, completion: { success in
|
|
println("enableNotificationFromUserWithUserID \(success)")
|
|
})
|
|
|
|
updateNotificationEnabled(true, forUserWithUserID: userID)
|
|
}
|
|
} else if let group = conversation.withGroup {
|
|
|
|
let groupID = group.groupID
|
|
|
|
if group.notificationEnabled {
|
|
|
|
disableNotificationFromCircleWithCircleID(groupID, failureHandler: nil, completion: { success in
|
|
println("disableNotificationFromUserWithUserID \(success)")
|
|
})
|
|
|
|
updateNotificationEnabled(false, forGroupWithGroupID: groupID)
|
|
|
|
} else {
|
|
enableNotificationFromCircleWithCircleID(groupID, failureHandler: nil, completion: {success in
|
|
println("enableNotificationFromCircleWithCircleID \(success)")
|
|
|
|
})
|
|
|
|
updateNotificationEnabled(true, forGroupWithGroupID: groupID)
|
|
}
|
|
}
|
|
}
|
|
|
|
func tryReport() {
|
|
|
|
guard let user = conversation.withFriend else {
|
|
return
|
|
}
|
|
|
|
let profileUser = ProfileUser.UserType(user)
|
|
report(.User(profileUser))
|
|
}
|
|
|
|
func updateBlocked(blocked: Bool, forUserWithUserID userID: String, needUpdateUI: Bool = true) {
|
|
|
|
guard let realm = try? Realm() else {
|
|
return
|
|
}
|
|
|
|
if let user = userWithUserID(userID, inRealm: realm) {
|
|
let _ = try? realm.write {
|
|
user.blocked = blocked
|
|
}
|
|
|
|
if needUpdateUI {
|
|
moreView.blocked = blocked
|
|
}
|
|
}
|
|
}
|
|
|
|
func toggleBlock() {
|
|
|
|
if let user = conversation.withFriend {
|
|
|
|
let userID = user.userID
|
|
|
|
if user.blocked {
|
|
unblockUserWithUserID(userID, failureHandler: nil, completion: { success in
|
|
println("unblockUserWithUserID \(success)")
|
|
|
|
self.updateBlocked(false, forUserWithUserID: userID)
|
|
})
|
|
|
|
} else {
|
|
blockUserWithUserID(userID, failureHandler: nil, completion: { success in
|
|
println("blockUserWithUserID \(success)")
|
|
|
|
self.updateBlocked(true, forUserWithUserID: userID)
|
|
})
|
|
}
|
|
}
|
|
}
|
|
|
|
func handleReceivedNewMessagesNotification(notification: NSNotification) {
|
|
|
|
guard let
|
|
messagesInfo = notification.object as? [String: AnyObject],
|
|
messageIDs = messagesInfo["messageIDs"] as? [String],
|
|
messageAgeRawValue = messagesInfo["messageAge"] as? String,
|
|
messageAge = MessageAge(rawValue: messageAgeRawValue) else {
|
|
println("Can NOT handleReceivedNewMessagesNotification")
|
|
return
|
|
}
|
|
|
|
handleRecievedNewMessages(messageIDs, messageAge: messageAge)
|
|
}
|
|
|
|
private func handleRecievedNewMessages(_messageIDs: [String], messageAge: MessageAge) {
|
|
|
|
var messageIDs: [String]?
|
|
|
|
//Make sure insert cell when in conversation viewcontroller
|
|
guard let conversationController = self.navigationController?.visibleViewController as? ConversationViewController else {
|
|
return
|
|
}
|
|
|
|
realm.refresh() // 确保是最新数据
|
|
|
|
// 按照 conversation 过滤消息，匹配的才能考虑插入
|
|
if let conversation = conversation {
|
|
|
|
if let conversationID = conversation.fakeID, realm = conversation.realm, currentVisibleConversationID = conversationController.conversation.fakeID {
|
|
|
|
if currentVisibleConversationID != conversationID {
|
|
return
|
|
}
|
|
|
|
var filteredMessageIDs = [String]()
|
|
|
|
for messageID in _messageIDs {
|
|
if let message = messageWithMessageID(messageID, inRealm: realm) {
|
|
if let messageInConversationID = message.conversation?.fakeID {
|
|
if messageInConversationID == conversationID {
|
|
filteredMessageIDs.append(messageID)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
messageIDs = filteredMessageIDs
|
|
}
|
|
}
|
|
|
|
|
|
// 在前台时才能做插入
|
|
|
|
if UIApplication.sharedApplication().applicationState == .Active {
|
|
updateConversationCollectionViewWithMessageIDs(messageIDs, messageAge: messageAge, scrollToBottom: false, success: { _ in
|
|
})
|
|
|
|
} else {
|
|
|
|
// 不然就先记下来
|
|
|
|
if let messageIDs = messageIDs {
|
|
for messageID in messageIDs {
|
|
inActiveNewMessageIDSet.insert(messageID)
|
|
println("inActiveNewMessageIDSet insert: \(messageID)")
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// App 进入前台时，根据通知插入处于后台状态时收到的消息
|
|
|
|
func tryInsertInActiveNewMessages(notification: NSNotification) {
|
|
|
|
if UIApplication.sharedApplication().applicationState == .Active {
|
|
|
|
if inActiveNewMessageIDSet.count > 0 {
|
|
updateConversationCollectionViewWithMessageIDs(Array(inActiveNewMessageIDSet), messageAge: .New, scrollToBottom: false, success: { _ in
|
|
})
|
|
|
|
inActiveNewMessageIDSet = []
|
|
|
|
println("insert inActiveNewMessageIDSet to CollectionView")
|
|
}
|
|
}
|
|
}
|
|
|
|
func updateConversationCollectionViewWithMessageIDs(messageIDs: [String]?, messageAge: MessageAge, scrollToBottom: Bool, success: (Bool) -> Void) {
|
|
|
|
// 重要
|
|
guard navigationController?.topViewController == self else { // 防止 pop/push 后，原来未释放的 VC 也执行这下面的代码
|
|
return
|
|
}
|
|
|
|
if messageIDs != nil {
|
|
batchMarkMessagesAsReaded()
|
|
}
|
|
|
|
let keyboardAndToolBarHeight = messageToolbarBottomConstraint.constant + CGRectGetHeight(messageToolbar.bounds)
|
|
|
|
adjustConversationCollectionViewWithMessageIDs(messageIDs, messageAge: messageAge, adjustHeight: keyboardAndToolBarHeight, scrollToBottom: scrollToBottom) { finished in
|
|
success(finished)
|
|
}
|
|
|
|
if messageIDs == nil {
|
|
afterSentMessageAction?()
|
|
}
|
|
}
|
|
|
|
func adjustConversationCollectionViewWithMessageIDs(messageIDs: [String]?, messageAge: MessageAge, adjustHeight: CGFloat, scrollToBottom: Bool, success: (Bool) -> Void) {
|
|
|
|
let _lastTimeMessagesCount = lastTimeMessagesCount
|
|
lastTimeMessagesCount = messages.count
|
|
|
|
// 保证是增加消息
|
|
if messages.count <= _lastTimeMessagesCount {
|
|
return
|
|
}
|
|
|
|
let newMessagesCount = Int(messages.count - _lastTimeMessagesCount)
|
|
|
|
let lastDisplayedMessagesRange = displayedMessagesRange
|
|
|
|
displayedMessagesRange.length += newMessagesCount
|
|
|
|
// 异常：两种计数不相等，治标：reload，避免插入
|
|
if let messageIDs = messageIDs {
|
|
if newMessagesCount != messageIDs.count {
|
|
reloadConversationCollectionView()
|
|
println("newMessagesCount != messageIDs.count")
|
|
#if DEBUG
|
|
YepAlert.alertSorry(message: "请截屏报告!\nnewMessagesCount: \(newMessagesCount)\nmessageIDs.count: \(messageIDs.count): \(messageIDs)", inViewController: self)
|
|
#endif
|
|
return
|
|
}
|
|
}
|
|
|
|
if newMessagesCount > 0 {
|
|
|
|
if let messageIDs = messageIDs {
|
|
|
|
var indexPaths = [NSIndexPath]()
|
|
|
|
for messageID in messageIDs {
|
|
if let
|
|
message = messageWithMessageID(messageID, inRealm: realm),
|
|
index = messages.indexOf(message) {
|
|
let indexPath = NSIndexPath(forItem: index - displayedMessagesRange.location, inSection: 0)
|
|
println("insert item: \(indexPath.item), \(index), \(displayedMessagesRange.location)")
|
|
|
|
indexPaths.append(indexPath)
|
|
|
|
} else {
|
|
println("unknown message")
|
|
|
|
#if DEBUG
|
|
YepAlert.alertSorry(message: "unknown message: \(messageID)", inViewController: self)
|
|
#endif
|
|
|
|
reloadConversationCollectionView()
|
|
return
|
|
}
|
|
}
|
|
|
|
switch messageAge {
|
|
|
|
case .New:
|
|
conversationCollectionView.insertItemsAtIndexPaths(indexPaths)
|
|
|
|
case .Old:
|
|
let bottomOffset = conversationCollectionView.contentSize.height - conversationCollectionView.contentOffset.y
|
|
CATransaction.begin()
|
|
CATransaction.setDisableActions(true)
|
|
|
|
conversationCollectionView.performBatchUpdates({ [weak self] in
|
|
self?.conversationCollectionView.insertItemsAtIndexPaths(indexPaths)
|
|
|
|
}, completion: { [weak self] finished in
|
|
if let strongSelf = self {
|
|
var contentOffset = strongSelf.conversationCollectionView.contentOffset
|
|
contentOffset.y = strongSelf.conversationCollectionView.contentSize.height - bottomOffset
|
|
|
|
strongSelf.conversationCollectionView.setContentOffset(contentOffset, animated: false)
|
|
|
|
CATransaction.commit()
|
|
|
|
// 上面的 CATransaction 保证了 CollectionView 在插入后不闪动
|
|
// 此时再做个 scroll 动画比较自然
|
|
let indexPath = NSIndexPath(forItem: newMessagesCount - 1, inSection: 0)
|
|
strongSelf.conversationCollectionView.scrollToItemAtIndexPath(indexPath, atScrollPosition: UICollectionViewScrollPosition.CenteredVertically, animated: true)
|
|
}
|
|
})
|
|
}
|
|
|
|
println("insert messages A")
|
|
|
|
} else {
|
|
println("self message")
|
|
|
|
// 这里做了一个假设：本地刚创建的消息比所有的已有的消息都要新，这在创建消息里做保证（服务器可能传回创建在“未来”的消息）
|
|
|
|
var indexPaths = [NSIndexPath]()
|
|
|
|
for i in 0..<newMessagesCount {
|
|
let indexPath = NSIndexPath(forItem: lastDisplayedMessagesRange.length + i, inSection: 0)
|
|
indexPaths.append(indexPath)
|
|
}
|
|
|
|
conversationCollectionView.insertItemsAtIndexPaths(indexPaths)
|
|
|
|
println("insert messages B")
|
|
}
|
|
}
|
|
|
|
if newMessagesCount > 0 {
|
|
|
|
var newMessagesTotalHeight: CGFloat = 0
|
|
for i in _lastTimeMessagesCount..<messages.count {
|
|
if let message = messages[safe: i] {
|
|
let height = heightOfMessage(message) + YepConfig.ChatCell.lineSpacing
|
|
newMessagesTotalHeight += height
|
|
}
|
|
}
|
|
|
|
let keyboardAndToolBarHeight = adjustHeight
|
|
|
|
let blockedHeight = topBarsHeight + (feedView != nil ? FeedView.foldHeight : 0) + keyboardAndToolBarHeight
|
|
|
|
let visibleHeight = conversationCollectionView.frame.height - blockedHeight
|
|
|
|
// cal the height can be used
|
|
let useableHeight = visibleHeight - conversationCollectionView.contentSize.height
|
|
|
|
if newMessagesTotalHeight > useableHeight {
|
|
|
|
UIView.animateWithDuration(0.2, delay: 0.0, options: UIViewAnimationOptions.CurveEaseInOut, animations: { [weak self] in
|
|
|
|
if let strongSelf = self {
|
|
|
|
if scrollToBottom {
|
|
let newContentSize = strongSelf.conversationCollectionView.collectionViewLayout.collectionViewContentSize()
|
|
let newContentOffsetY = newContentSize.height - strongSelf.conversationCollectionView.frame.height + keyboardAndToolBarHeight
|
|
strongSelf.conversationCollectionView.contentOffset.y = newContentOffsetY
|
|
|
|
} else {
|
|
strongSelf.conversationCollectionView.contentOffset.y += newMessagesTotalHeight
|
|
}
|
|
}
|
|
|
|
}, completion: { _ in
|
|
success(true)
|
|
})
|
|
|
|
} else {
|
|
success(true)
|
|
}
|
|
|
|
} else {
|
|
success(true)
|
|
}
|
|
}
|
|
|
|
func reloadConversationCollectionView() {
|
|
dispatch_async(dispatch_get_main_queue()) {
|
|
self.conversationCollectionView.reloadData()
|
|
}
|
|
}
|
|
|
|
func cleanTextInput() {
|
|
messageToolbar.messageTextView.text = ""
|
|
messageToolbar.state = .BeginTextInput
|
|
}
|
|
|
|
func updateStateInfoOfTitleView(titleView: ConversationTitleView) {
|
|
dispatch_async(dispatch_get_main_queue()) { [weak self] in
|
|
if let strongSelf = self {
|
|
if let timeAgo = lastSignDateOfConversation(strongSelf.conversation)?.timeAgo {
|
|
titleView.stateInfoLabel.text = String(format:NSLocalizedString("Last seen %@", comment: ""), timeAgo.lowercaseString)
|
|
} else if let friend = strongSelf.conversation.withFriend {
|
|
titleView.stateInfoLabel.text = String(format:NSLocalizedString("Last seen %@", comment: ""), NSDate(timeIntervalSince1970: friend.lastSignInUnixTime).timeAgo.lowercaseString)
|
|
} else {
|
|
titleView.stateInfoLabel.text = NSLocalizedString("Begin chat just now", comment: "")
|
|
}
|
|
|
|
titleView.stateInfoLabel.textColor = UIColor.grayColor()
|
|
}
|
|
}
|
|
}
|
|
|
|
func playMessageAudioWithMessage(message: Message?) {
|
|
|
|
if let audioPlayer = YepAudioService.sharedManager.audioPlayer {
|
|
if let playingMessage = YepAudioService.sharedManager.playingMessage {
|
|
if audioPlayer.playing {
|
|
|
|
audioPlayer.pause()
|
|
|
|
if let playbackTimer = YepAudioService.sharedManager.playbackTimer {
|
|
playbackTimer.invalidate()
|
|
}
|
|
|
|
if let sender = playingMessage.fromFriend, playingMessageIndex = messages.indexOf(playingMessage) {
|
|
|
|
let indexPath = NSIndexPath(forItem: playingMessageIndex - displayedMessagesRange.location, inSection: 0)
|
|
|
|
if sender.friendState != UserFriendState.Me.rawValue {
|
|
if let cell = conversationCollectionView.cellForItemAtIndexPath(indexPath) as? ChatLeftAudioCell {
|
|
cell.playing = false
|
|
}
|
|
|
|
} else {
|
|
if let cell = conversationCollectionView.cellForItemAtIndexPath(indexPath) as? ChatRightAudioCell {
|
|
cell.playing = false
|
|
}
|
|
}
|
|
}
|
|
|
|
if let message = message {
|
|
if message.messageID == playingMessage.messageID {
|
|
YepAudioService.sharedManager.resetToDefault()
|
|
return
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if let message = message {
|
|
let audioPlayedDuration = audioPlayedDurationOfMessage(message) as NSTimeInterval
|
|
YepAudioService.sharedManager.playAudioWithMessage(message, beginFromTime: audioPlayedDuration, delegate: self) {
|
|
let playbackTimer = NSTimer.scheduledTimerWithTimeInterval(0.02, target: self, selector: "updateAudioPlaybackProgress:", userInfo: nil, repeats: true)
|
|
YepAudioService.sharedManager.playbackTimer = playbackTimer
|
|
}
|
|
} else {
|
|
YepAudioService.sharedManager.resetToDefault()
|
|
}
|
|
}
|
|
|
|
func cleanForLogout() {
|
|
displayedMessagesRange.length = 0
|
|
}
|
|
|
|
// MARK: Navigation
|
|
|
|
override func prepareForSegue(segue: UIStoryboardSegue, sender: AnyObject?) {
|
|
|
|
guard let identifier = segue.identifier else {
|
|
return
|
|
}
|
|
|
|
messageToolbar.state = .Default
|
|
|
|
switch identifier {
|
|
|
|
case "showProfileFromFeedView":
|
|
|
|
let vc = segue.destinationViewController as! ProfileViewController
|
|
|
|
if let user = feedView?.feed?.creator {
|
|
vc.profileUser = ProfileUser.UserType(user)
|
|
}
|
|
|
|
vc.fromType = .GroupConversation
|
|
vc.setBackButtonWithTitle()
|
|
|
|
case "showProfile":
|
|
|
|
let vc = segue.destinationViewController as! ProfileViewController
|
|
|
|
if let user = sender as? User {
|
|
vc.profileUser = ProfileUser.UserType(user)
|
|
|
|
} else {
|
|
if let withFriend = conversation?.withFriend {
|
|
if withFriend.userID != YepUserDefaults.userID.value {
|
|
vc.profileUser = ProfileUser.UserType(withFriend)
|
|
}
|
|
}
|
|
}
|
|
|
|
switch conversation.type {
|
|
case ConversationType.OneToOne.rawValue:
|
|
vc.fromType = .OneToOneConversation
|
|
case ConversationType.Group.rawValue:
|
|
vc.fromType = .GroupConversation
|
|
default:
|
|
break
|
|
}
|
|
|
|
vc.setBackButtonWithTitle()
|
|
|
|
case "presentNewFeed":
|
|
|
|
guard let
|
|
nvc = segue.destinationViewController as? UINavigationController,
|
|
vc = nvc.topViewController as? NewFeedViewController
|
|
else {
|
|
return
|
|
}
|
|
|
|
vc.socialWork = sender as? MessageSocialWork
|
|
|
|
/*
|
|
case "showFeedMedia":
|
|
|
|
let info = sender as! [String: AnyObject]
|
|
|
|
let vc = segue.destinationViewController as! MessageMediaViewController
|
|
|
|
if let box = info["attachments"] as? Box<[DiscoveredAttachment]> {
|
|
let attachments = box.value
|
|
vc.previewMedias = attachments.map({ PreviewMedia.AttachmentType(attachment: $0) })
|
|
}
|
|
|
|
if let index = info["index"] as? Int {
|
|
vc.startIndex = index
|
|
}
|
|
|
|
let transitionView = info["transitionView"] as! UIImageView
|
|
|
|
let delegate = ConversationMessagePreviewNavigationControllerDelegate()
|
|
delegate.isFeedMedia = true
|
|
delegate.snapshot = UIScreen.mainScreen().snapshotViewAfterScreenUpdates(false)
|
|
|
|
var frame = transitionView.convertRect(transitionView.frame, toView: view)
|
|
delegate.frame = frame
|
|
if let image = transitionView.image {
|
|
let width = image.size.width
|
|
let height = image.size.height
|
|
if width > height {
|
|
let newWidth = frame.width * (width / height)
|
|
frame.origin.x -= (newWidth - frame.width) / 2
|
|
frame.size.width = newWidth
|
|
} else {
|
|
let newHeight = frame.height * (height / width)
|
|
frame.origin.y -= (newHeight - frame.height) / 2
|
|
frame.size.height = newHeight
|
|
}
|
|
delegate.thumbnailImage = image
|
|
}
|
|
delegate.thumbnailFrame = frame
|
|
|
|
delegate.transitionView = transitionView
|
|
|
|
navigationControllerDelegate = delegate
|
|
|
|
// 在自定义 push 之前，记录原始的 NavigationControllerDelegate 以便 pop 后恢复
|
|
originalNavigationControllerDelegate = navigationController!.delegate
|
|
|
|
navigationController?.delegate = delegate
|
|
|
|
case "showMessageMedia":
|
|
|
|
let vc = segue.destinationViewController as! MessageMediaViewController
|
|
|
|
if let info = sender as? [String: AnyObject], mediaMessages = info["mediaMessages"] as? [Message], index = info["index"] as? Int, message = mediaMessages[safe: index], messageIndex = messages.indexOf(message) {
|
|
|
|
// vc.previewMedias = [
|
|
// PreviewMedia.MessageType(message: message)
|
|
// ]
|
|
|
|
vc.previewMedias = mediaMessages.map({ PreviewMedia.MessageType(message: $0) })
|
|
|
|
vc.startIndex = index
|
|
|
|
let indexPath = NSIndexPath(forRow: messageIndex - displayedMessagesRange.location , inSection: 0)
|
|
|
|
if let cell = conversationCollectionView.cellForItemAtIndexPath(indexPath) {
|
|
|
|
var frame = CGRectZero
|
|
var transitionView: UIView?
|
|
|
|
if let sender = message.fromFriend {
|
|
if sender.friendState != UserFriendState.Me.rawValue {
|
|
switch message.mediaType {
|
|
|
|
case MessageMediaType.Image.rawValue:
|
|
let cell = cell as! ChatLeftImageCell
|
|
transitionView = cell.messageImageView
|
|
frame = cell.convertRect(cell.messageImageView.frame, toView: view)
|
|
|
|
case MessageMediaType.Video.rawValue:
|
|
let cell = cell as! ChatLeftVideoCell
|
|
transitionView = cell.thumbnailImageView
|
|
frame = cell.convertRect(cell.thumbnailImageView.frame, toView: view)
|
|
|
|
case MessageMediaType.Location.rawValue:
|
|
let cell = cell as! ChatLeftLocationCell
|
|
transitionView = cell.mapImageView
|
|
frame = cell.convertRect(cell.mapImageView.frame, toView: view)
|
|
|
|
default:
|
|
break
|
|
}
|
|
|
|
} else {
|
|
switch message.mediaType {
|
|
|
|
case MessageMediaType.Image.rawValue:
|
|
let cell = cell as! ChatRightImageCell
|
|
transitionView = cell.messageImageView
|
|
frame = cell.convertRect(cell.messageImageView.frame, toView: view)
|
|
|
|
case MessageMediaType.Video.rawValue:
|
|
let cell = cell as! ChatRightVideoCell
|
|
transitionView = cell.thumbnailImageView
|
|
frame = cell.convertRect(cell.thumbnailImageView.frame, toView: view)
|
|
|
|
case MessageMediaType.Location.rawValue:
|
|
let cell = cell as! ChatRightLocationCell
|
|
transitionView = cell.mapImageView
|
|
frame = cell.convertRect(cell.mapImageView.frame, toView: view)
|
|
|
|
default:
|
|
break
|
|
}
|
|
}
|
|
}
|
|
|
|
let delegate = ConversationMessagePreviewNavigationControllerDelegate()
|
|
delegate.snapshot = UIScreen.mainScreen().snapshotViewAfterScreenUpdates(false)
|
|
delegate.frame = frame
|
|
delegate.thumbnailFrame = frame
|
|
delegate.thumbnailImage = message.thumbnailImage
|
|
delegate.transitionView = transitionView
|
|
|
|
navigationControllerDelegate = delegate
|
|
|
|
// 在自定义 push 之前，记录原始的 NavigationControllerDelegate 以便 pop 后恢复
|
|
originalNavigationControllerDelegate = navigationController!.delegate
|
|
|
|
navigationController?.delegate = delegate
|
|
}
|
|
}
|
|
|
|
case "presentMessageMedia":
|
|
|
|
let vc = segue.destinationViewController as! MessageMediaViewController
|
|
|
|
if let message = sender as? Message, messageIndex = messages.indexOf(message) {
|
|
|
|
vc.previewMedias = [
|
|
PreviewMedia.MessageType(message: message)
|
|
]
|
|
|
|
let indexPath = NSIndexPath(forRow: messageIndex - displayedMessagesRange.location , inSection: 0)
|
|
|
|
if let cell = conversationCollectionView.cellForItemAtIndexPath(indexPath) {
|
|
|
|
var frame = CGRectZero
|
|
var transitionView: UIView?
|
|
|
|
if let sender = message.fromFriend {
|
|
if sender.friendState != UserFriendState.Me.rawValue {
|
|
switch message.mediaType {
|
|
|
|
case MessageMediaType.Image.rawValue:
|
|
let cell = cell as! ChatLeftImageCell
|
|
transitionView = cell.messageImageView
|
|
frame = cell.convertRect(cell.messageImageView.frame, toView: view)
|
|
|
|
case MessageMediaType.Video.rawValue:
|
|
let cell = cell as! ChatLeftVideoCell
|
|
transitionView = cell.thumbnailImageView
|
|
frame = cell.convertRect(cell.thumbnailImageView.frame, toView: view)
|
|
|
|
case MessageMediaType.Location.rawValue:
|
|
let cell = cell as! ChatLeftLocationCell
|
|
transitionView = cell.mapImageView
|
|
frame = cell.convertRect(cell.mapImageView.frame, toView: view)
|
|
|
|
default:
|
|
break
|
|
}
|
|
|
|
} else {
|
|
switch message.mediaType {
|
|
|
|
case MessageMediaType.Image.rawValue:
|
|
let cell = cell as! ChatRightImageCell
|
|
transitionView = cell.messageImageView
|
|
frame = cell.convertRect(cell.messageImageView.frame, toView: view)
|
|
|
|
case MessageMediaType.Video.rawValue:
|
|
let cell = cell as! ChatRightVideoCell
|
|
transitionView = cell.thumbnailImageView
|
|
frame = cell.convertRect(cell.thumbnailImageView.frame, toView: view)
|
|
|
|
case MessageMediaType.Location.rawValue:
|
|
let cell = cell as! ChatRightLocationCell
|
|
transitionView = cell.mapImageView
|
|
frame = cell.convertRect(cell.mapImageView.frame, toView: view)
|
|
|
|
default:
|
|
break
|
|
}
|
|
}
|
|
}
|
|
|
|
vc.modalPresentationStyle = UIModalPresentationStyle.Custom
|
|
|
|
let transitionManager = ConversationMessagePreviewTransitionManager()
|
|
transitionManager.frame = frame
|
|
transitionManager.transitionView = transitionView
|
|
|
|
vc.transitioningDelegate = transitionManager
|
|
|
|
messagePreviewTransitionManager = transitionManager
|
|
}
|
|
}
|
|
*/
|
|
case "presentPickLocation":
|
|
|
|
let nvc = segue.destinationViewController as! UINavigationController
|
|
let vc = nvc.topViewController as! PickLocationViewController
|
|
|
|
vc.sendLocationAction = { [weak self] locationInfo in
|
|
|
|
if let withFriend = self?.conversation.withFriend {
|
|
|
|
sendLocationWithLocationInfo(locationInfo, toRecipient: withFriend.userID, recipientType: "User", afterCreatedMessage: { message in
|
|
|
|
dispatch_async(dispatch_get_main_queue()) {
|
|
self?.updateConversationCollectionViewWithMessageIDs(nil, messageAge: .New, scrollToBottom: true, success: { _ in
|
|
})
|
|
}
|
|
|
|
}, failureHandler: { [weak self] reason, errorMessage in
|
|
defaultFailureHandler(reason, errorMessage: errorMessage)
|
|
|
|
YepAlert.alertSorry(message: NSLocalizedString("Failed to send location!\nTry tap on message to resend.", comment: ""), inViewController: self)
|
|
|
|
}, completion: { success -> Void in
|
|
println("sendLocation to friend: \(success)")
|
|
})
|
|
|
|
} else if let withGroup = self?.conversation.withGroup {
|
|
|
|
sendLocationWithLocationInfo(locationInfo, toRecipient: withGroup.groupID, recipientType: "Circle", afterCreatedMessage: { message in
|
|
dispatch_async(dispatch_get_main_queue()) {
|
|
self?.updateConversationCollectionViewWithMessageIDs(nil, messageAge: .New, scrollToBottom: true, success: { _ in
|
|
})
|
|
}
|
|
|
|
}, failureHandler: { [weak self] reason, errorMessage in
|
|
defaultFailureHandler(reason, errorMessage: errorMessage)
|
|
|
|
YepAlert.alertSorry(message: NSLocalizedString("Failed to send location!\nTry tap on message to resend.", comment: ""), inViewController: self)
|
|
|
|
}, completion: { success -> Void in
|
|
println("sendLocation to group: \(success)")
|
|
})
|
|
}
|
|
}
|
|
|
|
default:
|
|
break
|
|
}
|
|
}
|
|
}
|
|
|
|
// MARK: UIGestureRecognizerDelegate
|
|
|
|
extension ConversationViewController: UIGestureRecognizerDelegate {
|
|
|
|
func gestureRecognizerShouldBegin(gestureRecognizer: UIGestureRecognizer) -> Bool {
|
|
|
|
if let isAnimated = navigationController?.transitionCoordinator()?.isAnimated() {
|
|
return !isAnimated
|
|
}
|
|
|
|
if navigationController?.viewControllers.count < 2 {
|
|
return false
|
|
}
|
|
|
|
if gestureRecognizer == navigationController?.interactivePopGestureRecognizer {
|
|
return true
|
|
}
|
|
|
|
return false
|
|
}
|
|
}
|
|
|
|
// MARK: UICollectionViewDataSource, UICollectionViewDelegate
|
|
|
|
extension ConversationViewController: UICollectionViewDataSource, UICollectionViewDelegate {
|
|
|
|
func didRecieveMenuWillHideNotification(notification: NSNotification) {
|
|
|
|
println("Menu Will hide")
|
|
|
|
selectedIndexPathForMenu = nil
|
|
}
|
|
|
|
func didRecieveMenuWillShowNotification(notification: NSNotification) {
|
|
|
|
println("Menu Will show")
|
|
|
|
if let menu = notification.object as? UIMenuController,
|
|
selectedIndexPathForMenu = selectedIndexPathForMenu
|
|
{
|
|
|
|
var bubbleFrame = CGRectZero
|
|
|
|
if let cell = conversationCollectionView.cellForItemAtIndexPath(selectedIndexPathForMenu) as? ChatRightTextCell {
|
|
bubbleFrame = cell.convertRect(cell.textContainerView.frame, toView: view)
|
|
} else if let cell = conversationCollectionView.cellForItemAtIndexPath(selectedIndexPathForMenu) as? ChatLeftTextCell {
|
|
bubbleFrame = cell.convertRect(cell.textContainerView.frame, toView: view)
|
|
}else if let cell = conversationCollectionView.cellForItemAtIndexPath(selectedIndexPathForMenu) as? ChatLeftAudioCell {
|
|
bubbleFrame = cell.convertRect(cell.audioContainerView.frame, toView: view)
|
|
}else if let cell = conversationCollectionView.cellForItemAtIndexPath(selectedIndexPathForMenu) as? ChatRightAudioCell {
|
|
bubbleFrame = cell.convertRect(cell.audioContainerView.frame, toView: view)
|
|
}else if let cell = conversationCollectionView.cellForItemAtIndexPath(selectedIndexPathForMenu) as? ChatLeftVideoCell {
|
|
bubbleFrame = cell.convertRect(cell.thumbnailImageView.frame, toView: view)
|
|
}else if let cell = conversationCollectionView.cellForItemAtIndexPath(selectedIndexPathForMenu) as? ChatRightVideoCell {
|
|
bubbleFrame = cell.convertRect(cell.thumbnailImageView.frame, toView: view)
|
|
}else if let cell = conversationCollectionView.cellForItemAtIndexPath(selectedIndexPathForMenu) as? ChatLeftLocationCell {
|
|
bubbleFrame = cell.convertRect(cell.mapImageView.frame, toView: view)
|
|
}else if let cell = conversationCollectionView.cellForItemAtIndexPath(selectedIndexPathForMenu) as? ChatRightLocationCell {
|
|
bubbleFrame = cell.convertRect(cell.mapImageView.frame, toView: view)
|
|
}else if let cell = conversationCollectionView.cellForItemAtIndexPath(selectedIndexPathForMenu) as? ChatLeftImageCell{
|
|
bubbleFrame = cell.convertRect(cell.messageImageView.frame, toView: view)
|
|
}else if let cell = conversationCollectionView.cellForItemAtIndexPath(selectedIndexPathForMenu) as? ChatRightImageCell {
|
|
bubbleFrame = cell.convertRect(cell.messageImageView.frame, toView: view)
|
|
} else {
|
|
return
|
|
}
|
|
|
|
NSNotificationCenter.defaultCenter().removeObserver(self, name: UIMenuControllerWillShowMenuNotification, object: nil)
|
|
|
|
menu.setTargetRect(bubbleFrame, inView: view)
|
|
|
|
menu.setMenuVisible(true, animated: true)
|
|
|
|
NSNotificationCenter.defaultCenter().addObserver(self, selector: "didRecieveMenuWillShowNotification:", name: UIMenuControllerWillShowMenuNotification, object: nil)
|
|
}
|
|
}
|
|
|
|
func collectionView(collectionView: UICollectionView, canPerformAction action: Selector, forItemAtIndexPath indexPath: NSIndexPath, withSender sender: AnyObject?) -> Bool {
|
|
|
|
if let _ = conversationCollectionView.cellForItemAtIndexPath(indexPath) as? ChatRightTextCell {
|
|
if action == "copy:" {
|
|
return true
|
|
}
|
|
} else if let _ = conversationCollectionView.cellForItemAtIndexPath(indexPath) as? ChatLeftTextCell {
|
|
if action == "copy:" {
|
|
return true
|
|
}
|
|
}
|
|
|
|
if action == "deleteMessage:" {
|
|
return true
|
|
}
|
|
|
|
return false
|
|
}
|
|
|
|
func collectionView(collectionView: UICollectionView, performAction action: Selector, forItemAtIndexPath indexPath: NSIndexPath, withSender sender: AnyObject?) {
|
|
|
|
if let cell = conversationCollectionView.cellForItemAtIndexPath(indexPath) as? ChatRightTextCell {
|
|
if action == "copy:" {
|
|
UIPasteboard.generalPasteboard().string = cell.textContentTextView.text
|
|
}
|
|
} else if let cell = conversationCollectionView.cellForItemAtIndexPath(indexPath) as? ChatLeftTextCell {
|
|
if action == "copy:" {
|
|
UIPasteboard.generalPasteboard().string = cell.textContentTextView.text
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
func deleteMessageAtIndexPath(message: Message, indexPath: NSIndexPath) {
|
|
dispatch_async(dispatch_get_main_queue()) { [weak self] in
|
|
if let strongSelf = self, realm = message.realm {
|
|
|
|
var sectionDateMessage: Message?
|
|
|
|
if let currentMessageIndex = strongSelf.messages.indexOf(message) {
|
|
|
|
let previousMessageIndex = currentMessageIndex - 1
|
|
|
|
if let previousMessage = strongSelf.messages[safe: previousMessageIndex] {
|
|
|
|
if previousMessage.mediaType == MessageMediaType.SectionDate.rawValue {
|
|
sectionDateMessage = previousMessage
|
|
}
|
|
}
|
|
}
|
|
|
|
let currentIndexPath: NSIndexPath
|
|
if let index = strongSelf.messages.indexOf(message) {
|
|
currentIndexPath = NSIndexPath(forItem: index - strongSelf.displayedMessagesRange.location, inSection: indexPath.section)
|
|
} else {
|
|
currentIndexPath = indexPath
|
|
}
|
|
|
|
if let sectionDateMessage = sectionDateMessage {
|
|
|
|
var canDeleteTwoMessages = false // 考虑刚好的边界情况，例如消息为本束的最后一条，而 sectionDate 在上一束中
|
|
if strongSelf.displayedMessagesRange.length >= 2 {
|
|
strongSelf.displayedMessagesRange.length -= 2
|
|
canDeleteTwoMessages = true
|
|
|
|
} else {
|
|
if strongSelf.displayedMessagesRange.location >= 1 {
|
|
strongSelf.displayedMessagesRange.location -= 1
|
|
}
|
|
strongSelf.displayedMessagesRange.length -= 1
|
|
}
|
|
|
|
let _ = try? realm.write {
|
|
if let mediaMetaData = sectionDateMessage.mediaMetaData {
|
|
realm.delete(mediaMetaData)
|
|
}
|
|
if let mediaMetaData = message.mediaMetaData {
|
|
realm.delete(mediaMetaData)
|
|
}
|
|
realm.delete(sectionDateMessage)
|
|
realm.delete(message)
|
|
}
|
|
|
|
if canDeleteTwoMessages {
|
|
let previousIndexPath = NSIndexPath(forItem: currentIndexPath.item - 1, inSection: currentIndexPath.section)
|
|
strongSelf.conversationCollectionView.deleteItemsAtIndexPaths([previousIndexPath, currentIndexPath])
|
|
} else {
|
|
strongSelf.conversationCollectionView.deleteItemsAtIndexPaths([currentIndexPath])
|
|
}
|
|
|
|
} else {
|
|
strongSelf.displayedMessagesRange.length -= 1
|
|
let _ = try? realm.write {
|
|
if let mediaMetaData = message.mediaMetaData {
|
|
realm.delete(mediaMetaData)
|
|
}
|
|
realm.delete(message)
|
|
}
|
|
strongSelf.conversationCollectionView.deleteItemsAtIndexPaths([currentIndexPath])
|
|
}
|
|
|
|
// 必须更新，插入时需要
|
|
strongSelf.lastTimeMessagesCount = strongSelf.messages.count
|
|
}
|
|
}
|
|
}
|
|
|
|
func collectionView(collectionView: UICollectionView, shouldShowMenuForItemAtIndexPath indexPath: NSIndexPath) -> Bool {
|
|
|
|
selectedIndexPathForMenu = indexPath
|
|
|
|
if let _ = conversationCollectionView.cellForItemAtIndexPath(indexPath) as? ChatBaseCell {
|
|
|
|
return true
|
|
} else {
|
|
selectedIndexPathForMenu = nil
|
|
}
|
|
|
|
return false
|
|
}
|
|
|
|
func numberOfSectionsInCollectionView(collectionView: UICollectionView) -> Int {
|
|
return 1
|
|
}
|
|
|
|
func collectionView(collectionView: UICollectionView, numberOfItemsInSection section: Int) -> Int {
|
|
return displayedMessagesRange.length
|
|
}
|
|
|
|
private func tryShowMessageMediaFromMessage(message: Message) {
|
|
|
|
if let messageIndex = messages.indexOf(message) {
|
|
|
|
let indexPath = NSIndexPath(forRow: messageIndex - displayedMessagesRange.location , inSection: 0)
|
|
|
|
if let cell = conversationCollectionView.cellForItemAtIndexPath(indexPath) {
|
|
|
|
var frame = CGRectZero
|
|
var image: UIImage?
|
|
var transitionView: UIView?
|
|
|
|
if let sender = message.fromFriend {
|
|
if sender.friendState != UserFriendState.Me.rawValue {
|
|
switch message.mediaType {
|
|
|
|
case MessageMediaType.Image.rawValue:
|
|
let cell = cell as! ChatLeftImageCell
|
|
image = cell.messageImageView.image
|
|
transitionView = cell.messageImageView
|
|
frame = cell.convertRect(cell.messageImageView.frame, toView: view)
|
|
|
|
case MessageMediaType.Video.rawValue:
|
|
let cell = cell as! ChatLeftVideoCell
|
|
image = cell.thumbnailImageView.image
|
|
transitionView = cell.thumbnailImageView
|
|
frame = cell.convertRect(cell.thumbnailImageView.frame, toView: view)
|
|
|
|
default:
|
|
break
|
|
}
|
|
|
|
} else {
|
|
switch message.mediaType {
|
|
|
|
case MessageMediaType.Image.rawValue:
|
|
let cell = cell as! ChatRightImageCell
|
|
image = cell.messageImageView.image
|
|
transitionView = cell.messageImageView
|
|
frame = cell.convertRect(cell.messageImageView.frame, toView: view)
|
|
|
|
case MessageMediaType.Video.rawValue:
|
|
let cell = cell as! ChatRightVideoCell
|
|
image = cell.thumbnailImageView.image
|
|
transitionView = cell.thumbnailImageView
|
|
frame = cell.convertRect(cell.thumbnailImageView.frame, toView: view)
|
|
|
|
default:
|
|
break
|
|
}
|
|
}
|
|
}
|
|
|
|
guard image != nil else {
|
|
return
|
|
}
|
|
|
|
let vc = UIStoryboard(name: "MediaPreview", bundle: nil).instantiateViewControllerWithIdentifier("MediaPreviewViewController") as! MediaPreviewViewController
|
|
|
|
if message.mediaType == MessageMediaType.Video.rawValue {
|
|
vc.previewMedias = [PreviewMedia.MessageType(message: message)]
|
|
vc.startIndex = 0
|
|
|
|
} else {
|
|
let predicate = NSPredicate(format: "mediaType = %d", MessageMediaType.Image.rawValue)
|
|
let mediaMessagesResult = messages.filter(predicate)
|
|
let mediaMessages = mediaMessagesResult.map({ $0 })
|
|
|
|
if let index = mediaMessagesResult.indexOf(message) {
|
|
vc.previewMedias = mediaMessages.map({ PreviewMedia.MessageType(message: $0) })
|
|
vc.startIndex = index
|
|
}
|
|
}
|
|
|
|
vc.previewImageViewInitalFrame = frame
|
|
vc.topPreviewImage = message.thumbnailImage
|
|
vc.bottomPreviewImage = image
|
|
|
|
delay(0.0, work: { () -> Void in
|
|
transitionView?.alpha = 0 // 放到下一个 Runloop 避免太快消失产生闪烁
|
|
})
|
|
|
|
vc.afterDismissAction = { [weak self] in
|
|
transitionView?.alpha = 1
|
|
self?.view.window?.makeKeyAndVisible()
|
|
}
|
|
|
|
mediaPreviewWindow.rootViewController = vc
|
|
mediaPreviewWindow.windowLevel = UIWindowLevelAlert - 1
|
|
mediaPreviewWindow.makeKeyAndVisible()
|
|
}
|
|
}
|
|
|
|
/*
|
|
if message.mediaType == MessageMediaType.Video.rawValue {
|
|
performSegueWithIdentifier("showMessageMedia", sender: ["mediaMessages": [message], "index": 0])
|
|
|
|
} else {
|
|
let predicate = NSPredicate(format: "mediaType = %d", MessageMediaType.Image.rawValue)
|
|
|
|
let mediaMessagesResult = messages.filter(predicate)
|
|
|
|
let mediaMessages = mediaMessagesResult.map({ $0 })
|
|
|
|
if let index = mediaMessagesResult.indexOf(message) {
|
|
|
|
performSegueWithIdentifier("showMessageMedia", sender: ["mediaMessages": mediaMessages, "index": index])
|
|
}
|
|
}
|
|
*/
|
|
}
|
|
|
|
func collectionView(collectionView: UICollectionView, cellForItemAtIndexPath indexPath: NSIndexPath) -> UICollectionViewCell {
|
|
|
|
if let message = messages[safe: (displayedMessagesRange.location + indexPath.item)] {
|
|
|
|
if message.mediaType == MessageMediaType.SectionDate.rawValue {
|
|
|
|
let cell = collectionView.dequeueReusableCellWithReuseIdentifier(chatSectionDateCellIdentifier, forIndexPath: indexPath) as! ChatSectionDateCell
|
|
return cell
|
|
}
|
|
|
|
if let sender = message.fromFriend {
|
|
|
|
if sender.friendState != UserFriendState.Me.rawValue { // from Friend
|
|
|
|
switch message.mediaType {
|
|
|
|
case MessageMediaType.Image.rawValue:
|
|
|
|
let cell = collectionView.dequeueReusableCellWithReuseIdentifier(chatLeftImageCellIdentifier, forIndexPath: indexPath) as! ChatLeftImageCell
|
|
return cell
|
|
|
|
case MessageMediaType.Audio.rawValue:
|
|
|
|
let cell = collectionView.dequeueReusableCellWithReuseIdentifier(chatLeftAudioCellIdentifier, forIndexPath: indexPath) as! ChatLeftAudioCell
|
|
return cell
|
|
|
|
case MessageMediaType.Video.rawValue:
|
|
|
|
let cell = collectionView.dequeueReusableCellWithReuseIdentifier(chatLeftVideoCellIdentifier, forIndexPath: indexPath) as! ChatLeftVideoCell
|
|
return cell
|
|
|
|
case MessageMediaType.Location.rawValue:
|
|
|
|
let cell = collectionView.dequeueReusableCellWithReuseIdentifier(chatLeftLocationCellIdentifier, forIndexPath: indexPath) as! ChatLeftLocationCell
|
|
return cell
|
|
|
|
case MessageMediaType.SocialWork.rawValue:
|
|
|
|
let cell = collectionView.dequeueReusableCellWithReuseIdentifier(chatLeftSocialWorkCellIdentifier, forIndexPath: indexPath) as! ChatLeftSocialWorkCell
|
|
return cell
|
|
|
|
default:
|
|
|
|
let cell = collectionView.dequeueReusableCellWithReuseIdentifier(chatLeftTextCellIdentifier, forIndexPath: indexPath) as! ChatLeftTextCell
|
|
return cell
|
|
}
|
|
|
|
} else { // from Me
|
|
|
|
switch message.mediaType {
|
|
|
|
case MessageMediaType.Image.rawValue:
|
|
|
|
let cell = collectionView.dequeueReusableCellWithReuseIdentifier(chatRightImageCellIdentifier, forIndexPath: indexPath) as! ChatRightImageCell
|
|
return cell
|
|
|
|
case MessageMediaType.Audio.rawValue:
|
|
|
|
let cell = collectionView.dequeueReusableCellWithReuseIdentifier(chatRightAudioCellIdentifier, forIndexPath: indexPath) as! ChatRightAudioCell
|
|
return cell
|
|
|
|
case MessageMediaType.Video.rawValue:
|
|
|
|
let cell = collectionView.dequeueReusableCellWithReuseIdentifier(chatRightVideoCellIdentifier, forIndexPath: indexPath) as! ChatRightVideoCell
|
|
return cell
|
|
|
|
case MessageMediaType.Location.rawValue:
|
|
|
|
let cell = collectionView.dequeueReusableCellWithReuseIdentifier(chatRightLocationCellIdentifier, forIndexPath: indexPath) as! ChatRightLocationCell
|
|
return cell
|
|
|
|
default:
|
|
|
|
let cell = collectionView.dequeueReusableCellWithReuseIdentifier(chatRightTextCellIdentifier, forIndexPath: indexPath) as! ChatRightTextCell
|
|
return cell
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
println("🐌 Conversation: Should not be there")
|
|
|
|
let cell = collectionView.dequeueReusableCellWithReuseIdentifier(chatSectionDateCellIdentifier, forIndexPath: indexPath) as! ChatSectionDateCell
|
|
cell.sectionDateLabel.text = "🐌"
|
|
|
|
return cell
|
|
}
|
|
|
|
func collectionView(collectionView: UICollectionView, willDisplayCell cell: UICollectionViewCell, forItemAtIndexPath indexPath: NSIndexPath) {
|
|
|
|
if let message = messages[safe: (displayedMessagesRange.location + indexPath.item)] {
|
|
|
|
let longPressAction: () -> Void = { [weak self] in
|
|
self?.deleteMessageAtIndexPath(message, indexPath: indexPath)
|
|
}
|
|
|
|
if message.mediaType == MessageMediaType.SectionDate.rawValue {
|
|
|
|
if let cell = cell as? ChatSectionDateCell {
|
|
let createdAt = NSDate(timeIntervalSince1970: message.createdUnixTime)
|
|
|
|
if createdAt.isInCurrentWeek() {
|
|
cell.sectionDateLabel.text = sectionDateInCurrentWeekFormatter.stringFromDate(createdAt)
|
|
|
|
} else {
|
|
cell.sectionDateLabel.text = sectionDateFormatter.stringFromDate(createdAt)
|
|
}
|
|
}
|
|
|
|
return
|
|
}
|
|
|
|
if let sender = message.fromFriend {
|
|
|
|
if let cell = cell as? ChatBaseCell {
|
|
if let _ = self.conversation.withGroup {
|
|
cell.inGroup = true
|
|
}
|
|
cell.tapAvatarAction = { [weak self] user in
|
|
self?.performSegueWithIdentifier("showProfile", sender: user)
|
|
}
|
|
|
|
cell.longPressAction = longPressAction
|
|
}
|
|
|
|
if sender.friendState != UserFriendState.Me.rawValue { // from Friend
|
|
|
|
switch message.mediaType {
|
|
|
|
case MessageMediaType.Image.rawValue:
|
|
|
|
if let cell = cell as? ChatLeftImageCell {
|
|
|
|
cell.configureWithMessage(message, messageImagePreferredWidth: messageImagePreferredWidth, messageImagePreferredHeight: messageImagePreferredHeight, messageImagePreferredAspectRatio: messageImagePreferredAspectRatio, mediaTapAction: { [weak self] in
|
|
|
|
if message.downloadState == MessageDownloadState.Downloaded.rawValue {
|
|
|
|
if let messageTextView = self?.messageToolbar.messageTextView {
|
|
if messageTextView.isFirstResponder() {
|
|
self?.messageToolbar.state = .Default
|
|
return
|
|
}
|
|
}
|
|
|
|
self?.tryShowMessageMediaFromMessage(message)
|
|
|
|
} else {
|
|
//YepAlert.alertSorry(message: NSLocalizedString("Please wait while the image is not ready!", comment: ""), inViewController: self)
|
|
}
|
|
|
|
}, collectionView: collectionView, indexPath: indexPath)
|
|
}
|
|
|
|
case MessageMediaType.Audio.rawValue:
|
|
|
|
if let cell = cell as? ChatLeftAudioCell {
|
|
|
|
let audioPlayedDuration = audioPlayedDurationOfMessage(message)
|
|
|
|
cell.configureWithMessage(message, audioPlayedDuration: audioPlayedDuration, audioBubbleTapAction: { [weak self] in
|
|
|
|
if message.downloadState == MessageDownloadState.Downloaded.rawValue {
|
|
self?.playMessageAudioWithMessage(message)
|
|
|
|
} else {
|
|
//YepAlert.alertSorry(message: NSLocalizedString("Please wait while the audio is not ready!", comment: ""), inViewController: self)
|
|
}
|
|
|
|
}, collectionView: collectionView, indexPath: indexPath)
|
|
}
|
|
|
|
case MessageMediaType.Video.rawValue:
|
|
|
|
if let cell = cell as? ChatLeftVideoCell {
|
|
|
|
cell.configureWithMessage(message, messageImagePreferredWidth: messageImagePreferredWidth, messageImagePreferredHeight: messageImagePreferredHeight, messageImagePreferredAspectRatio: self.messageImagePreferredAspectRatio, mediaTapAction: { [weak self] in
|
|
|
|
if message.downloadState == MessageDownloadState.Downloaded.rawValue {
|
|
|
|
if let messageTextView = self?.messageToolbar.messageTextView {
|
|
if messageTextView.isFirstResponder() {
|
|
self?.messageToolbar.state = .Default
|
|
return
|
|
}
|
|
}
|
|
|
|
self?.tryShowMessageMediaFromMessage(message)
|
|
|
|
} else {
|
|
//YepAlert.alertSorry(message: NSLocalizedString("Please wait while the video is not ready!", comment: ""), inViewController: self)
|
|
}
|
|
|
|
}, collectionView: collectionView, indexPath: indexPath)
|
|
}
|
|
|
|
case MessageMediaType.Location.rawValue:
|
|
|
|
if let cell = cell as? ChatLeftLocationCell {
|
|
|
|
cell.configureWithMessage(message, mediaTapAction: {
|
|
if let coordinate = message.coordinate {
|
|
let locationCoordinate = CLLocationCoordinate2D(latitude: coordinate.latitude, longitude: coordinate.longitude)
|
|
let mapItem = MKMapItem(placemark: MKPlacemark(coordinate: locationCoordinate, addressDictionary: nil))
|
|
mapItem.name = message.textContent
|
|
/*
|
|
let launchOptions = [MKLaunchOptionsDirectionsModeKey: MKLaunchOptionsDirectionsModeDriving]
|
|
mapItem.openInMapsWithLaunchOptions(launchOptions)
|
|
*/
|
|
mapItem.openInMapsWithLaunchOptions(nil)
|
|
}
|
|
|
|
}, collectionView: collectionView, indexPath: indexPath)
|
|
}
|
|
|
|
case MessageMediaType.SocialWork.rawValue:
|
|
|
|
if let cell = cell as? ChatLeftSocialWorkCell {
|
|
cell.configureWithMessage(message)
|
|
|
|
cell.createFeedAction = { [weak self] socialWork in
|
|
|
|
self?.performSegueWithIdentifier("presentNewFeed", sender: socialWork)
|
|
}
|
|
}
|
|
|
|
default:
|
|
|
|
if let cell = cell as? ChatLeftTextCell {
|
|
|
|
cell.configureWithMessage(message, textContentLabelWidth: textContentLabelWidthOfMessage(message), collectionView: collectionView, indexPath: indexPath)
|
|
}
|
|
}
|
|
|
|
} else { // from Me
|
|
|
|
switch message.mediaType {
|
|
|
|
case MessageMediaType.Image.rawValue:
|
|
|
|
if let cell = cell as? ChatRightImageCell {
|
|
|
|
cell.configureWithMessage(message, messageImagePreferredWidth: messageImagePreferredWidth, messageImagePreferredHeight: messageImagePreferredHeight, messageImagePreferredAspectRatio: messageImagePreferredAspectRatio, mediaTapAction: { [weak self] in
|
|
|
|
if message.sendState == MessageSendState.Failed.rawValue {
|
|
|
|
YepAlert.confirmOrCancel(title: NSLocalizedString("Action", comment: ""), message: NSLocalizedString("Resend image?", comment: ""), confirmTitle: NSLocalizedString("Resend", comment: ""), cancelTitle: NSLocalizedString("Cancel", comment: ""), inViewController: self, withConfirmAction: {
|
|
|
|
resendMessage(message, failureHandler: { [weak self] reason, errorMessage in
|
|
defaultFailureHandler(reason, errorMessage: errorMessage)
|
|
|
|
YepAlert.alertSorry(message: NSLocalizedString("Failed to resend image!\nPlease make sure your iPhone is connected to the Internet.", comment: ""), inViewController: self)
|
|
|
|
}, completion: { success in
|
|
println("resendImage: \(success)")
|
|
})
|
|
|
|
}, cancelAction: {
|
|
})
|
|
|
|
} else {
|
|
if let messageTextView = self?.messageToolbar.messageTextView {
|
|
if messageTextView.isFirstResponder() {
|
|
self?.messageToolbar.state = .Default
|
|
return
|
|
}
|
|
}
|
|
|
|
self?.tryShowMessageMediaFromMessage(message)
|
|
}
|
|
|
|
}, collectionView: collectionView, indexPath: indexPath)
|
|
}
|
|
|
|
case MessageMediaType.Audio.rawValue:
|
|
|
|
if let cell = cell as? ChatRightAudioCell {
|
|
|
|
let audioPlayedDuration = audioPlayedDurationOfMessage(message)
|
|
|
|
cell.configureWithMessage(message, audioPlayedDuration: audioPlayedDuration, audioBubbleTapAction: { [weak self] in
|
|
|
|
if message.sendState == MessageSendState.Failed.rawValue {
|
|
|
|
YepAlert.confirmOrCancel(title: NSLocalizedString("Action", comment: ""), message: NSLocalizedString("Resend audio?", comment: ""), confirmTitle: NSLocalizedString("Resend", comment: ""), cancelTitle: NSLocalizedString("Cancel", comment: ""), inViewController: self, withConfirmAction: {
|
|
|
|
resendMessage(message, failureHandler: { [weak self] reason, errorMessage in
|
|
defaultFailureHandler(reason, errorMessage: errorMessage)
|
|
|
|
YepAlert.alertSorry(message: NSLocalizedString("Failed to resend audio!\nPlease make sure your iPhone is connected to the Internet.", comment: ""), inViewController: self)
|
|
|
|
}, completion: { success in
|
|
println("resendAudio: \(success)")
|
|
})
|
|
|
|
}, cancelAction: {
|
|
})
|
|
|
|
return
|
|
}
|
|
|
|
self?.playMessageAudioWithMessage(message)
|
|
|
|
}, collectionView: collectionView, indexPath: indexPath)
|
|
}
|
|
|
|
case MessageMediaType.Video.rawValue:
|
|
|
|
if let cell = cell as? ChatRightVideoCell {
|
|
|
|
cell.configureWithMessage(message, messageImagePreferredWidth:messageImagePreferredWidth, messageImagePreferredHeight: messageImagePreferredHeight, messageImagePreferredAspectRatio: messageImagePreferredAspectRatio, mediaTapAction: { [weak self] in
|
|
|
|
if message.sendState == MessageSendState.Failed.rawValue {
|
|
|
|
YepAlert.confirmOrCancel(title: NSLocalizedString("Action", comment: ""), message: NSLocalizedString("Resend video?", comment: ""), confirmTitle: NSLocalizedString("Resend", comment: ""), cancelTitle: NSLocalizedString("Cancel", comment: ""), inViewController: self, withConfirmAction: {
|
|
|
|
resendMessage(message, failureHandler: { [weak self] reason, errorMessage in
|
|
defaultFailureHandler(reason, errorMessage: errorMessage)
|
|
|
|
YepAlert.alertSorry(message: NSLocalizedString("Failed to resend video!\nPlease make sure your iPhone is connected to the Internet.", comment: ""), inViewController: self)
|
|
|
|
}, completion: { success in
|
|
println("resendVideo: \(success)")
|
|
})
|
|
|
|
}, cancelAction: {
|
|
})
|
|
|
|
} else {
|
|
if let messageTextView = self?.messageToolbar.messageTextView {
|
|
if messageTextView.isFirstResponder() {
|
|
self?.messageToolbar.state = .Default
|
|
return
|
|
}
|
|
}
|
|
|
|
self?.tryShowMessageMediaFromMessage(message)
|
|
}
|
|
|
|
}, collectionView: collectionView, indexPath: indexPath)
|
|
}
|
|
|
|
case MessageMediaType.Location.rawValue:
|
|
|
|
if let cell = cell as? ChatRightLocationCell {
|
|
|
|
cell.configureWithMessage(message, mediaTapAction: { [weak self] in
|
|
|
|
if message.sendState == MessageSendState.Failed.rawValue {
|
|
|
|
YepAlert.confirmOrCancel(title: NSLocalizedString("Action", comment: ""), message: NSLocalizedString("Resend location?", comment: ""), confirmTitle: NSLocalizedString("Resend", comment: ""), cancelTitle: NSLocalizedString("Cancel", comment: ""), inViewController: self, withConfirmAction: {
|
|
|
|
resendMessage(message, failureHandler: { [weak self] reason, errorMessage in
|
|
defaultFailureHandler(reason, errorMessage: errorMessage)
|
|
|
|
YepAlert.alertSorry(message: NSLocalizedString("Failed to resend location!\nPlease make sure your iPhone is connected to the Internet.", comment: ""), inViewController: self)
|
|
|
|
}, completion: { success in
|
|
println("resendLocation: \(success)")
|
|
})
|
|
|
|
}, cancelAction: {
|
|
})
|
|
|
|
} else {
|
|
if let coordinate = message.coordinate {
|
|
let locationCoordinate = CLLocationCoordinate2D(latitude: coordinate.latitude, longitude: coordinate.longitude)
|
|
let mapItem = MKMapItem(placemark: MKPlacemark(coordinate: locationCoordinate, addressDictionary: nil))
|
|
mapItem.name = message.textContent
|
|
/*
|
|
let launchOptions = [MKLaunchOptionsDirectionsModeKey: MKLaunchOptionsDirectionsModeDriving]
|
|
mapItem.openInMapsWithLaunchOptions(launchOptions)
|
|
*/
|
|
mapItem.openInMapsWithLaunchOptions(nil)
|
|
}
|
|
}
|
|
|
|
}, collectionView: collectionView, indexPath: indexPath)
|
|
}
|
|
|
|
default:
|
|
|
|
if let cell = cell as? ChatRightTextCell {
|
|
|
|
cell.configureWithMessage(message, textContentLabelWidth: textContentLabelWidthOfMessage(message), mediaTapAction: { [weak self] in
|
|
|
|
if message.sendState == MessageSendState.Failed.rawValue {
|
|
|
|
YepAlert.confirmOrCancel(title: NSLocalizedString("Action", comment: ""), message: NSLocalizedString("Resend text?", comment: ""), confirmTitle: NSLocalizedString("Resend", comment: ""), cancelTitle: NSLocalizedString("Cancel", comment: ""), inViewController: self, withConfirmAction: {
|
|
|
|
resendMessage(message, failureHandler: { [weak self] reason, errorMessage in
|
|
defaultFailureHandler(reason, errorMessage: errorMessage)
|
|
|
|
YepAlert.alertSorry(message: NSLocalizedString("Failed to resend text!\nPlease make sure your iPhone is connected to the Internet.", comment: ""), inViewController: self)
|
|
|
|
}, completion: { success in
|
|
println("resendText: \(success)")
|
|
})
|
|
|
|
}, cancelAction: {
|
|
})
|
|
}
|
|
}, collectionView: collectionView, indexPath: indexPath)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
func collectionView(collectionView: UICollectionView!, layout collectionViewLayout: UICollectionViewLayout!, sizeForItemAtIndexPath indexPath: NSIndexPath!) -> CGSize {
|
|
|
|
if let message = messages[safe: (displayedMessagesRange.location + indexPath.item)] {
|
|
|
|
let height = heightOfMessage(message)
|
|
|
|
return CGSize(width: collectionViewWidth, height: height)
|
|
|
|
} else {
|
|
return CGSize(width: collectionViewWidth, height: 0)
|
|
}
|
|
}
|
|
|
|
func collectionView(collectionView: UICollectionView, layout collectionViewLayout: UICollectionViewLayout, insetForSectionAtIndex section: Int) -> UIEdgeInsets {
|
|
return UIEdgeInsets(top: sectionInsetTop, left: 0, bottom: sectionInsetBottom, right: 0)
|
|
}
|
|
|
|
|
|
func collectionView(collectionView: UICollectionView, didSelectItemAtIndexPath indexPath: NSIndexPath) {
|
|
|
|
switch messageToolbar.state {
|
|
|
|
case .BeginTextInput, .TextInputing:
|
|
messageToolbar.state = .Default
|
|
|
|
default:
|
|
break
|
|
}
|
|
}
|
|
|
|
// MARK: UIScrollViewDelegate
|
|
|
|
func scrollViewWillBeginDragging(scrollView: UIScrollView) {
|
|
|
|
let location = scrollView.panGestureRecognizer.locationInView(view)
|
|
dragBeginLocation = location
|
|
}
|
|
|
|
func scrollViewDidScroll(scrollView: UIScrollView) {
|
|
|
|
pullToRefreshView.scrollViewDidScroll(scrollView)
|
|
|
|
if let dragBeginLocation = dragBeginLocation {
|
|
let location = scrollView.panGestureRecognizer.locationInView(view)
|
|
let deltaY = location.y - dragBeginLocation.y
|
|
|
|
if deltaY < -30 {
|
|
tryFoldFeedView()
|
|
}
|
|
}
|
|
}
|
|
|
|
func scrollViewWillEndDragging(scrollView: UIScrollView, withVelocity velocity: CGPoint, targetContentOffset: UnsafeMutablePointer<CGPoint>) {
|
|
|
|
pullToRefreshView.scrollViewWillEndDragging(scrollView, withVelocity: velocity, targetContentOffset: targetContentOffset)
|
|
|
|
dragBeginLocation = nil
|
|
}
|
|
|
|
}
|
|
|
|
// MARK: FayeServiceDelegate
|
|
|
|
extension ConversationViewController: FayeServiceDelegate {
|
|
|
|
func fayeRecievedInstantStateType(instantStateType: FayeService.InstantStateType, userID: String) {
|
|
|
|
if let withFriend = conversation.withFriend {
|
|
|
|
if userID == withFriend.userID {
|
|
|
|
let content = NSLocalizedString(" is ", comment: "正在") + "\(instantStateType)"
|
|
|
|
titleView.stateInfoLabel.text = "\(content)..."
|
|
titleView.stateInfoLabel.textColor = UIColor.yepTintColor()
|
|
|
|
switch instantStateType {
|
|
|
|
case .Text:
|
|
self.typingResetDelay = 0.5
|
|
|
|
case .Audio:
|
|
self.typingResetDelay = 2.5
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/*
|
|
func fayeRecievedNewMessages(messageIDs: [String], messageAgeRawValue: MessageAge.RawValue) {
|
|
|
|
guard let
|
|
messageAge = MessageAge(rawValue: messageAgeRawValue) else {
|
|
println("Can NOT handleReceivedNewMessagesNotification")
|
|
return
|
|
}
|
|
|
|
handleRecievedNewMessages(messageIDs, messageAge: messageAge)
|
|
}
|
|
|
|
func fayeMessagesMarkAsReadByRecipient(lastReadAt: NSTimeInterval, recipientType: String, recipientID: String) {
|
|
|
|
if recipientID == conversation.recipient?.ID && recipientType == conversation.recipient?.type.nameForServer {
|
|
self.markAsReadAllSentMesagesBeforeUnixTime(lastReadAt)
|
|
}
|
|
}
|
|
*/
|
|
}
|
|
|
|
// MARK: PullToRefreshViewDelegate
|
|
|
|
extension ConversationViewController: PullToRefreshViewDelegate {
|
|
|
|
func pulllToRefreshViewDidRefresh(pulllToRefreshView: PullToRefreshView) {
|
|
|
|
if displayedMessagesRange.location == 0 {
|
|
|
|
if let recipient = conversation.recipient {
|
|
|
|
let timeDirection: TimeDirection
|
|
if let maxMessageID = messages.first?.messageID {
|
|
timeDirection = .Past(maxMessageID: maxMessageID)
|
|
} else {
|
|
timeDirection = .None
|
|
}
|
|
|
|
messagesFromRecipient(recipient, withTimeDirection: timeDirection, failureHandler: nil, completion: { messageIDs in
|
|
println("messagesFromRecipient: \(messageIDs.count)")
|
|
|
|
dispatch_async(dispatch_get_main_queue()) {
|
|
pulllToRefreshView.endRefreshingAndDoFurtherAction() {
|
|
dispatch_async(dispatch_get_main_queue()) {
|
|
tryPostNewMessagesReceivedNotificationWithMessageIDs(messageIDs, messageAge: timeDirection.messageAge)
|
|
//self?.fayeRecievedNewMessages(messageIDs, messageAgeRawValue: timeDirection.messageAge.rawValue)
|
|
}
|
|
}
|
|
}
|
|
})
|
|
}
|
|
|
|
} else {
|
|
|
|
delay(0.5) {
|
|
|
|
pulllToRefreshView.endRefreshingAndDoFurtherAction() { [weak self] in
|
|
|
|
if let strongSelf = self {
|
|
//let lastDisplayedMessagesRange = strongSelf.displayedMessagesRange
|
|
|
|
var newMessagesCount = strongSelf.messagesBunchCount
|
|
|
|
if (strongSelf.displayedMessagesRange.location - newMessagesCount) < 0 {
|
|
newMessagesCount = strongSelf.displayedMessagesRange.location
|
|
}
|
|
|
|
if newMessagesCount > 0 {
|
|
strongSelf.displayedMessagesRange.location -= newMessagesCount
|
|
strongSelf.displayedMessagesRange.length += newMessagesCount
|
|
|
|
strongSelf.lastTimeMessagesCount = strongSelf.messages.count // 同样需要纪录它
|
|
|
|
var indexPaths = [NSIndexPath]()
|
|
for i in 0..<newMessagesCount {
|
|
let indexPath = NSIndexPath(forItem: Int(i), inSection: 0)
|
|
indexPaths.append(indexPath)
|
|
}
|
|
|
|
let bottomOffset = strongSelf.conversationCollectionView.contentSize.height - strongSelf.conversationCollectionView.contentOffset.y
|
|
|
|
CATransaction.begin()
|
|
CATransaction.setDisableActions(true)
|
|
|
|
strongSelf.conversationCollectionView.performBatchUpdates({ [weak self] in
|
|
self?.conversationCollectionView.insertItemsAtIndexPaths(indexPaths)
|
|
|
|
}, completion: { [weak self] finished in
|
|
if let strongSelf = self {
|
|
var contentOffset = strongSelf.conversationCollectionView.contentOffset
|
|
contentOffset.y = strongSelf.conversationCollectionView.contentSize.height - bottomOffset
|
|
|
|
strongSelf.conversationCollectionView.setContentOffset(contentOffset, animated: false)
|
|
|
|
CATransaction.commit()
|
|
|
|
// 上面的 CATransaction 保证了 CollectionView 在插入后不闪动
|
|
// 此时再做个 scroll 动画比较自然
|
|
let indexPath = NSIndexPath(forItem: newMessagesCount - 1, inSection: 0)
|
|
strongSelf.conversationCollectionView.scrollToItemAtIndexPath(indexPath, atScrollPosition: UICollectionViewScrollPosition.CenteredVertically, animated: true)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
func scrollView() -> UIScrollView {
|
|
return conversationCollectionView
|
|
}
|
|
}
|
|
|
|
// MARK: AVAudioRecorderDelegate
|
|
|
|
extension ConversationViewController : AVAudioRecorderDelegate {
|
|
|
|
func audioRecorderDidFinishRecording(recorder: AVAudioRecorder, successfully flag: Bool) {
|
|
println("finished recording \(flag)")
|
|
}
|
|
|
|
func audioRecorderEncodeErrorDidOccur(recorder: AVAudioRecorder, error: NSError?) {
|
|
println("\(error?.localizedDescription)")
|
|
}
|
|
}
|
|
|
|
// MARK: AVAudioPlayerDelegate
|
|
|
|
extension ConversationViewController: AVAudioPlayerDelegate {
|
|
|
|
func audioPlayerBeginInterruption(player: AVAudioPlayer) {
|
|
|
|
println("audioPlayerBeginInterruption")
|
|
|
|
if let playbackTimer = YepAudioService.sharedManager.playbackTimer {
|
|
playbackTimer.invalidate()
|
|
}
|
|
}
|
|
|
|
func audioPlayerDecodeErrorDidOccur(player: AVAudioPlayer, error: NSError?) {
|
|
|
|
println("audioPlayerDecodeErrorDidOccur")
|
|
}
|
|
|
|
func audioPlayerDidFinishPlaying(player: AVAudioPlayer, successfully flag: Bool) {
|
|
|
|
UIDevice.currentDevice().proximityMonitoringEnabled = false
|
|
|
|
println("audioPlayerDidFinishPlaying \(flag)")
|
|
|
|
if let playbackTimer = YepAudioService.sharedManager.playbackTimer {
|
|
playbackTimer.invalidate()
|
|
}
|
|
|
|
if let playingMessage = YepAudioService.sharedManager.playingMessage {
|
|
setAudioPlayedDuration(0, ofMessage: playingMessage)
|
|
println("setAudioPlayedDuration to 0")
|
|
}
|
|
|
|
func nextUnplayedAudioMessageFrom(message: Message) -> Message? {
|
|
|
|
if let index = messages.indexOf(message) {
|
|
for i in (index + 1)..<messages.count {
|
|
if let message = messages[safe: i], friend = message.fromFriend {
|
|
if friend.friendState != UserFriendState.Me.rawValue {
|
|
if (message.mediaType == MessageMediaType.Audio.rawValue) && (message.mediaPlayed == false) {
|
|
return message
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
// 尝试播放下一个未播放过的语音消息
|
|
if let playingMessage = YepAudioService.sharedManager.playingMessage {
|
|
let message = nextUnplayedAudioMessageFrom(playingMessage)
|
|
playMessageAudioWithMessage(message)
|
|
|
|
} else {
|
|
YepAudioService.sharedManager.resetToDefault()
|
|
}
|
|
}
|
|
|
|
func audioPlayerEndInterruption(player: AVAudioPlayer) {
|
|
|
|
println("audioPlayerEndInterruption")
|
|
}
|
|
}
|
|
|
|
// MARK: UIImagePicker
|
|
|
|
extension ConversationViewController: UIImagePickerControllerDelegate, UINavigationControllerDelegate {
|
|
|
|
func imagePickerController(picker: UIImagePickerController, didFinishPickingMediaWithInfo info: [String : AnyObject]) {
|
|
|
|
if let mediaType = info[UIImagePickerControllerMediaType] as? String {
|
|
|
|
switch mediaType {
|
|
|
|
case kUTTypeImage as! String:
|
|
|
|
if let image = info[UIImagePickerControllerOriginalImage] as? UIImage {
|
|
|
|
let imageWidth = image.size.width
|
|
let imageHeight = image.size.height
|
|
|
|
let fixedImageWidth: CGFloat
|
|
let fixedImageHeight: CGFloat
|
|
|
|
if imageWidth > imageHeight {
|
|
fixedImageWidth = min(imageWidth, YepConfig.Media.imageWidth)
|
|
fixedImageHeight = imageHeight * (fixedImageWidth / imageWidth)
|
|
} else {
|
|
fixedImageHeight = min(imageHeight, YepConfig.Media.imageHeight)
|
|
fixedImageWidth = imageWidth * (fixedImageHeight / imageHeight)
|
|
}
|
|
|
|
let fixedSize = CGSize(width: fixedImageWidth, height: fixedImageHeight)
|
|
|
|
// resize to smaller, not need fixRotation
|
|
|
|
if let fixedImage = image.resizeToSize(fixedSize, withInterpolationQuality: CGInterpolationQuality.High) {
|
|
sendImage(fixedImage)
|
|
}
|
|
}
|
|
|
|
case kUTTypeMovie as! String:
|
|
|
|
if let videoURL = info[UIImagePickerControllerMediaURL] as? NSURL {
|
|
println("videoURL \(videoURL)")
|
|
sendVideoWithVideoURL(videoURL)
|
|
}
|
|
|
|
default:
|
|
break
|
|
}
|
|
}
|
|
|
|
dismissViewControllerAnimated(true, completion: nil)
|
|
}
|
|
|
|
func sendImage(image: UIImage) {
|
|
|
|
// Prepare meta data
|
|
|
|
let metaDataString = metaDataStringOfImage(image, needBlurThumbnail: true)
|
|
|
|
// Do send
|
|
|
|
let imageData = UIImageJPEGRepresentation(image, YepConfig.messageImageCompressionQuality())!
|
|
|
|
let messageImageName = NSUUID().UUIDString
|
|
|
|
if let withFriend = conversation.withFriend {
|
|
|
|
sendImageInFilePath(nil, orFileData: imageData, metaData: metaDataString, toRecipient: withFriend.userID, recipientType: "User", afterCreatedMessage: { [weak self] message in
|
|
|
|
dispatch_async(dispatch_get_main_queue()) {
|
|
|
|
if let _ = NSFileManager.saveMessageImageData(imageData, withName: messageImageName) {
|
|
if let realm = message.realm {
|
|
let _ = try? realm.write {
|
|
message.localAttachmentName = messageImageName
|
|
message.mediaType = MessageMediaType.Image.rawValue
|
|
if let metaDataString = metaDataString {
|
|
message.mediaMetaData = mediaMetaDataFromString(metaDataString, inRealm: realm)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
self?.updateConversationCollectionViewWithMessageIDs(nil, messageAge: .New, scrollToBottom: true, success: { _ in
|
|
})
|
|
}
|
|
|
|
}, failureHandler: { [weak self] reason, errorMessage in
|
|
defaultFailureHandler(reason, errorMessage: errorMessage)
|
|
|
|
YepAlert.alertSorry(message: NSLocalizedString("Failed to send image!\nTry tap on message to resend.", comment: ""), inViewController: self)
|
|
|
|
}, completion: { success -> Void in
|
|
println("sendImage to friend: \(success)")
|
|
})
|
|
|
|
} else if let withGroup = conversation.withGroup {
|
|
|
|
sendImageInFilePath(nil, orFileData: imageData, metaData: metaDataString, toRecipient: withGroup.groupID, recipientType: "Circle", afterCreatedMessage: { [weak self] message in
|
|
|
|
dispatch_async(dispatch_get_main_queue()) {
|
|
if let _ = NSFileManager.saveMessageImageData(imageData, withName: messageImageName) {
|
|
if let realm = message.realm {
|
|
let _ = try? realm.write {
|
|
message.localAttachmentName = messageImageName
|
|
message.mediaType = MessageMediaType.Image.rawValue
|
|
if let metaDataString = metaDataString {
|
|
message.mediaMetaData = mediaMetaDataFromString(metaDataString, inRealm: realm)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
self?.updateConversationCollectionViewWithMessageIDs(nil, messageAge: .New, scrollToBottom: true, success: { _ in
|
|
})
|
|
}
|
|
|
|
}, failureHandler: { [weak self] reason, errorMessage in
|
|
defaultFailureHandler(reason, errorMessage: errorMessage)
|
|
|
|
YepAlert.alertSorry(message: NSLocalizedString("Failed to send image!\nTry tap on message to resend.", comment: ""), inViewController: self)
|
|
|
|
}, completion: { success in
|
|
println("sendImage to group: \(success)")
|
|
})
|
|
}
|
|
}
|
|
|
|
func sendVideoWithVideoURL(videoURL: NSURL) {
|
|
|
|
// Prepare meta data
|
|
|
|
var metaData: String? = nil
|
|
|
|
var thumbnailData: NSData?
|
|
|
|
if let image = thumbnailImageOfVideoInVideoURL(videoURL) {
|
|
|
|
let imageWidth = image.size.width
|
|
let imageHeight = image.size.height
|
|
|
|
let thumbnailWidth: CGFloat
|
|
let thumbnailHeight: CGFloat
|
|
|
|
if imageWidth > imageHeight {
|
|
thumbnailWidth = min(imageWidth, YepConfig.MetaData.thumbnailMaxSize)
|
|
thumbnailHeight = imageHeight * (thumbnailWidth / imageWidth)
|
|
} else {
|
|
thumbnailHeight = min(imageHeight, YepConfig.MetaData.thumbnailMaxSize)
|
|
thumbnailWidth = imageWidth * (thumbnailHeight / imageHeight)
|
|
}
|
|
|
|
let videoMetaDataInfo: [String: AnyObject]
|
|
|
|
let thumbnailSize = CGSize(width: thumbnailWidth, height: thumbnailHeight)
|
|
|
|
if let thumbnail = image.resizeToSize(thumbnailSize, withInterpolationQuality: CGInterpolationQuality.Low) {
|
|
let blurredThumbnail = thumbnail.blurredImageWithRadius(5, iterations: 7, tintColor: UIColor.clearColor())
|
|
|
|
let data = UIImageJPEGRepresentation(blurredThumbnail, 0.7)!
|
|
|
|
let string = data.base64EncodedStringWithOptions(NSDataBase64EncodingOptions(rawValue: 0))
|
|
|
|
println("video blurredThumbnail string length: \(string.lengthOfBytesUsingEncoding(NSUTF8StringEncoding))\n")
|
|
|
|
videoMetaDataInfo = [
|
|
YepConfig.MetaData.videoWidth: imageWidth,
|
|
YepConfig.MetaData.videoHeight: imageHeight,
|
|
YepConfig.MetaData.blurredThumbnailString: string,
|
|
]
|
|
|
|
} else {
|
|
videoMetaDataInfo = [
|
|
YepConfig.MetaData.videoWidth: imageWidth,
|
|
YepConfig.MetaData.videoHeight: imageHeight,
|
|
]
|
|
}
|
|
|
|
if let videoMetaData = try? NSJSONSerialization.dataWithJSONObject(videoMetaDataInfo, options: []) {
|
|
let videoMetaDataString = NSString(data: videoMetaData, encoding: NSUTF8StringEncoding) as? String
|
|
metaData = videoMetaDataString
|
|
}
|
|
|
|
thumbnailData = UIImageJPEGRepresentation(image, YepConfig.messageImageCompressionQuality())
|
|
}
|
|
|
|
let messageVideoName = NSUUID().UUIDString
|
|
|
|
let afterCreatedMessageAction = { [weak self] (message: Message) in
|
|
|
|
dispatch_async(dispatch_get_main_queue()) {
|
|
|
|
if let videoData = NSData(contentsOfURL: videoURL) {
|
|
|
|
if let _ = NSFileManager.saveMessageVideoData(videoData, withName: messageVideoName) {
|
|
if let realm = message.realm {
|
|
let _ = try? realm.write {
|
|
|
|
if let thumbnailData = thumbnailData {
|
|
if let _ = NSFileManager.saveMessageImageData(thumbnailData, withName: messageVideoName) {
|
|
message.localThumbnailName = messageVideoName
|
|
}
|
|
}
|
|
|
|
message.localAttachmentName = messageVideoName
|
|
|
|
message.mediaType = MessageMediaType.Video.rawValue
|
|
if let metaDataString = metaData {
|
|
message.mediaMetaData = mediaMetaDataFromString(metaDataString, inRealm: realm)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
self?.updateConversationCollectionViewWithMessageIDs(nil, messageAge: .New, scrollToBottom: true, success: { _ in
|
|
})
|
|
}
|
|
}
|
|
}
|
|
|
|
if let withFriend = conversation.withFriend {
|
|
|
|
sendVideoInFilePath(videoURL.path!, orFileData: nil, metaData: metaData, toRecipient: withFriend.userID, recipientType: "User", afterCreatedMessage: afterCreatedMessageAction, failureHandler: { [weak self] reason, errorMessage in
|
|
defaultFailureHandler(reason, errorMessage: errorMessage)
|
|
|
|
YepAlert.alertSorry(message: NSLocalizedString("Failed to send video!\nTry tap on message to resend.", comment: ""), inViewController: self)
|
|
|
|
}, completion: { success in
|
|
println("sendVideo to friend: \(success)")
|
|
})
|
|
|
|
} else if let withGroup = conversation.withGroup {
|
|
|
|
sendVideoInFilePath(videoURL.path!, orFileData: nil, metaData: metaData, toRecipient: withGroup.groupID, recipientType: "Circle", afterCreatedMessage: afterCreatedMessageAction, failureHandler: { [weak self] reason, errorMessage in
|
|
defaultFailureHandler(reason, errorMessage: errorMessage)
|
|
|
|
YepAlert.alertSorry(message: NSLocalizedString("Failed to send video!\nTry tap on message to resend.", comment: ""), inViewController: self)
|
|
|
|
}, completion: { success in
|
|
println("sendVideo to group: \(success)")
|
|
})
|
|
}
|
|
}
|
|
}
|
|
|