Swift自定义表情键盘+录音

。

这里没有干货，也没有教程，请各位大神手下留情。这个 demo 是平时自己在工作之余学习 swift 写的,因为每天学习时间有限所以这个 demo 前后写了一个月左右,里面的语法和命名都不是很规范，也没有做大量的机型和版本测试,整体语法偏向于OC。在写的期间也查询了许多资料以及API 的用法，其中有一部分逻辑和 emoji 表情资源是来自于VernonVan的这篇博客，我也并无抄袭之意，只是单纯的去练习和使用swift语法仅此而已。其他素材均来自于iconfont。

看图知意

这个思维导图展示的是各个子控件的层级关系，也包含了部分逻辑。demo中页面联动和旋转适配未做。

花开两朵各表一枝

从 emoji 说起

demo 整体业务逻辑占很大内容，其他都是子控件的堆叠并没有很高的难度系数，只要处理好控件之间的逻辑关系就能很好的实现动画效果。

在做 emoji 表情的时候还在想怎么实现表情与文字的转换，如：:joy: -> [笑哭] 这种形式，因为与服务器进行数据交互将表情作为图片做数据传递是非常不合理的，并且还要考虑到表情与文字之间的相互转化关系，所以demo 中用到的是将 emoji 当中富文本的 Attachment 属性来处理然后给相应的表情打Tag。来看一下具体代码：

//点击 emoji 事件
func didClickEmoji(with model: MYEmojiModel) {

    guard let image = UIImage.image(name: model.imageName!, path: "emoji") else {
        print("图片找不到")
        return
    }
    // 记录textView光标当前位置
    let selectedRange = self.textView.selectedRange
    // 将 emoji 标记为[name] 这种形式
    let emojiString = "[\(model.emojiDescription!)]"
    // 通过字体大小设置 emoji 大小
    let font = UIFont.systemFont(ofSize: MYTextViewTextFont)
    let emojiHeight = font.lineHeight
    // emoji 图片附件
    let attachment = NSTextAttachment()
    attachment.image = image
    attachment.bounds = .init(x: 0, y: font.descender, width: emojiHeight, height: emojiHeight)
    let attachString = NSAttributedString(attachment: attachment)
    // 将图片附件转为 NSMutableAttributedString
    let emojiAttributedString = NSMutableAttributedString(attributedString: attachString)
    // 将这段文字打上标记,key 自己定义，value 为[name]，这样做方便遍历和表情与文字替换
    emojiAttributedString.addAttribute(NSAttributedString.Key(rawValue: MYAddEmojiTag), value: emojiString, range: .init(location: 0, length: attachString.length))
    // 获取输入框中的富文本
    let attributedText = NSMutableAttributedString(attributedString: self.textView.attributedText)
    // 将打好标记的富文本替换到光标位置
    attributedText.replaceCharacters(in: selectedRange, with: emojiAttributedString)
    self.textView.attributedText = attributedText
    self.textView.selectedRange = .init(location: selectedRange.location + emojiAttributedString.length, length: 0)
    // 重新设置 font 是为了避免 emoji 在文字末尾导致光标变小
    self.textView.font = font
    //重新计算文字高度，来做自适应
    self.textViewDidChange(self.textView)
}
复制代码

因为在 emoji 被点击的时候就被打上相应的tag，value 是对应的文字描述，所以在富文本转字符串时就比较方便了。

//将 string 转为 NSString为了方便做字符串截取
let string = attribute.string as NSString
//遍历富文本，筛选出被打标记的富文本    
attribute.enumerateAttribute(NSAttributedString.Key(rawValue: MYAddEmojiTag), 
in: range, options: NSAttributedString.EnumerationOptions.longestEffectiveRangeNotRequired) { (value, range, stop) in
        if value != nil {
        	// value即 emoji 对应的描述信息
           	let tagString = value as! String
            result = result + tagString
            
        }else{
            let rangString = string.substring(with: range)
            result = result + rangString
        }
}
复制代码

复制粘贴的实现

通过上面的代码就已经实现文字<=>富文本的相互转换了，因为 textView 自带复制粘贴功能，而 UIPasteboard 粘贴板是没有 attributedText 属性的，当复制或剪切时只能将 textView.attributedText 转为文字，当粘贴的时候只能将文字转为富文本。因为在emoji 键盘被点击的时候你已经知道 emoji 相对应的文字描述，而如果粘贴为纯文字，那如何知道相对应的 emoji 呢？是的，用的是正则匹配，也是盗用别人的逻辑，但是 VernonVan 他的工程中的正则表达式是有点瑕疵的。在正则表达式上我做了改进，匹配规则如下：

• 你好[smile] -> [smile]
• 你好[smile.png] -> [smile.png]
• 你好[smile_] -> [smile_]
• 你好[a[smile]] -> [smile]
• 你好[][[[smile]] -> []、[smile]

只做了 a-z 下划线和.的匹配，如果想匹配更多内容自己添加规则即可。正则表达式不是很会写，只是尝试着想了这几种规则，想要验证和学习的可以去正则验证网站学习。具体代码实现在工程： Targets->Utils->Keyboard->Resources->MYMatchingEmojiManager 文件中

//正则验证网站:https://c.runoob.com/front-end/854 
//表达式: \[([a-z_.])+?\]
let regex = try! NSRegularExpression.init(pattern: "\\[([a-z_.])+?\\]")
//用表达式匹配结果
let results = regex.matches(in: string
        , options: NSRegularExpression.MatchingOptions.reportProgress, range: .init(location: 0, length: string.count))
复制代码

输入框与表情页切换动画

引用别人的话：“真正的键盘也就是说调起表情键盘时输入框是有光标的，能进行拖拽光标、选中区域等的操作，这样的体验才是与系统键盘一致的。其实系统已经提供好了接口给我们直接使用， UITextView 和 UITextField 都有的 inputView 和 inputAccessoryView 就是用来实现自定义键盘的”。但是有一种情况是：如果表情键盘的高度低于系统字体键盘的高度，那么在切换表情键盘与文字键盘的时候是有落差的，这个落差导致 textView 在回落的过程中，字体键盘瞬间切换表情键盘会有一个间隙把当前页面的内容暴露出来个零点几秒，非常影响美观，而系统的文字键盘高度和 emoji 键盘高度时一致的所以没有这个问题。解决办法我暂时就想起来两种：

1. 当 textView 的 keyboardWillShow 通知执行时，将 textView 的 superView 的高度等于 textView.height + emojiView.height 这样 supeView 的高度就会很大，这样在回落的过程中就不会显示位移缝隙，还可以为 emoji 视图加向上滚动的动画，这样切换就会更加衔接。
2. 不用 textView 的 inputView 属性，做一个假的 emoji 表情页，微信的键盘就是一个假的，因为当切换到表情页时， textView 就失去了响应，光标就消失了，这样就造成了键盘回落而 emoji 键盘向上滚动的效果，我在工程中就是用的这种方式。

无论是文字切换语音、文字切表情、语音切表情或者其他功能的任意切换，都是经过以下方法（具体实现见 demo）：

private var keyboardType : MYKeyboardInputViewEnum.KeyboardType = .None {
		//默认没有任何属性，为.None
		//相当于OC中的重写 set 方法
        willSet{
        if keyboardType == newValue {
        //如果将要改变的值与当前值一样，则不做任何操作，即同一种模式
            return
        }
        //不相同则重新赋值
        self.keyboardType = newValue;
        switch newValue {
        //判断哪种模式，处理相应的逻辑，具体实现见工程代码
        case .Emoji:
            break
        case .System:
            break
        case .Funcs:
            break
        case .Record:
            break
        default:
            break
        }
        
    }
}
复制代码

语音边录边转的实现

语音录制逻辑是这样婶的。

1. 每点击一次录音按钮便创建一个录音机，创建录音机的同时会创建两个路径： .caf 路径和 .mp3 路径， .caf 路径是录音机录制的文件存放路径， .mp3 路径则为转换后的文件路径。以及录音机的一些必要参数：

   /// 设置录音格式 默认kAudioFormatLinearPCM
   var formatIDKey : AudioFormatID = kAudioFormatLinearPCM
   /// 设置录音采样率(Hz) 8000/44100/96000（影响音频的质量） 默认 44100
   var sampleRateKey : NSInteger = 44100
   /// 录音通道数  1 或 2 默认为2
   var channelsKey : NSInteger = 2
   /// 线性采样位数  8、16、24、32 默认 16
   var bitDepthKey : NSInteger = 16
   /// 录音的质量 默认QualityMin
   var qualityKey : AVAudioQuality = .min
   复制代码

2. 录制时间为60秒，前1S内为初始化录音机时间，如果1S内取消录制则提示"录音时间太短",执行取消录制方法，删除两个文件；如果没有取消则继续录制，展示录制动画，增加手势滑动效果，增加语音消息呼吸灯动画，当录制完毕后在转换回调中删除录制相对应的 .caf 文件，抛出转换成功的 .mp3 文件路径。

3. 录制成功后，拿到相对应的 .mp3 文件路径上传到服务器，因为在上传过程必为异步上传（如果为主线程那不就卡了），有可能当前文件未上传成功后续又有文件要上传，所以要记得加锁，加锁，加锁保证数据的安全。demo 中这一部分并没有实现。

4. 取消发送，则删除两个对应的文件，结束转换

5. 录制时间到直接发送，上滑取消，声波监测等等。。。

具体实现见demo内 Utils->Keyboard->Tool->Recorder 文件，边录边转的实现见 ConverAudioFile 文件，转换是用的 lame.framework 的三方库。

swift基本语法

常用属性

只读属性（readonly） 在OC语法中因为存在 .h 和 .m 两个文件，所以想暴露给外部使用的接口和方法是全部定义在 .h 文件中的而 swift 则是全部写在同一个文件中的。如果你想定义一个属性为只读属性：

OC写法

.h文件定义
@property (nonatomic, assign,readonly) BOOL isHidden;
.m文件实现
- (BOOL)isHidden{}
复制代码

swift写法

//只实现 get 方法
var isHidden : BOOL {
	get{
	return true
	}
}
复制代码

有时候你需要定义一个属性，外部为只读而内部可以读写，OC是非常好实现的

.h文件定义
@property (nonatomic, assign,readonly) BOOL isHidden;
.m文件实现
@property (nonatomic, assign) BOOL isHidden;
这样就可实现一个外部只读内部读写功能
复制代码

而 swift 实现方法有很多种，你可以定义一个方法，内部定义一个为 private 的属性，将这个属性返回出去。还有更简便的写法

//意思是内部实现 set 方法，外部只可调用 get 方法
private(set) var isHidden  = true
复制代码

设置代理 OC 中是这样写的

@protocol MYEmojiProtocolDelegate <NSObject>
//必须实现
- (void) didClickDelete;
@optional 可选实现
- (void) didClickSend;

@end
复制代码

设置代理属性：

@property (nonatomic, weak) id<MYEmojiProtocolDelegate> delegate;
复制代码

swift 写法

protocol MYEmojiProtocolDelegate : NSObjectProtocol {
	func didClickDelete()
}
复制代码

设置代理属性：

weak var pageDelegate : MYEmojiProtocolDelegate?
复制代码

如果 swift 代理方法想设置成 option 可选方法，则方法需要加 @objc 前缀， protocol 前也是需要加 @objc 的，被标识为@objc属性，使得它兼容OC代码，拥有可选方法的协议只能被类遵守而枚举和结构体是不能遵守协议的。还有一种做法就是对协议进行方法扩展：

extension MYEmojiProtocolDelegate {
    //扩展代理的方法是必须实现的
    func didClickSend()  {
        
    }
}
复制代码

在学习 swift 的时候发现OC中的代理与 swift 中的协议，这是两种不同的概念，我们也知道 swift 是一门面向协议的编程，因为是初学 swift 对其理解还是比较浅的，下面谈谈我对面向协议的理解。

protocol 是一些方法或属性的名称，自我理解像是方法和属性（或者属性）的集合。只定义接口或者属性而不实现任何功能，如果某个 类型 （不是类；类型包括：类，枚举，结构体）想要遵守一个协议，那它需要实现这个协议所定义的所有这些内容。swift 里的 protocol 不仅可以定义方法还可定义属性，这与 OC 里的有所不同。

从实现方法说起

举个栗子：为 UITableViewcell 实现点击事件即：

func tableView(_ tableView: UITableView, didSelectRowAt indexPath: IndexPath) {
    //增加个点击调用方法
    didClick()        
}
复制代码

因为有不同的 UITableViewcell 的子类都需要实现这个方法，那我们应该怎么做呢？

继承 可以很好的解决这个问题，但是缺点是带来耦合性。如果再实现一个呼吸效果呢，就又在 Base 类中实现相应的代码，很快 Base 类就变得臃肿，且任何代码都可以写进去，而子类也完全不知道实现了父类的哪些方法。

Extension/Category 大家肯定在项目中用到的比较多，也很实用。直接为 UITableViewcell 写一个扩展，那意味着项目里所有的 UITableViewcell 对象都可以访问这个方法，如果 UICollectionCell 也需要上面的方法呢？也写扩展，粘贴复制同样的代码，我们都知道这两个类都继承自 UIView ，那直接给 UIView 添加扩展，这样项目中所有继承自 UIView 的对象都可以访问这个方法，为了一个类就污染了其他对象，因为这些对象根本不需要这些方法。

使用协议解决问题

定义一个protocol

protocol MYCompatible {
    // 定义属性
    //必须明确指定该属性支持的操作：只读（get）或者是可读写（get set）
    // 要用 var 定义属性，即使只有 get 方法
    var name: String {get set}
    var birthday : String {get}
    // 定义方法
    //protocol中的约定方法，当方法中有参数时是不能有默认值的
    func eat(food: String)
    //如果需要改变自身的值，需要在方法前面加mutating关键字
    mutating func changeName(name: String)
}
复制代码

定一个类或者结构体实现该协议

//遵守协议，实现协议的方法  就上面例子而言，只需要将`UITableviewCell`类遵守协议即可
class MYExtension: MYCompatible {

    var name: String = "xiaoma"
    let birthday: String = "1994"
    
    func eat(food: String = "KFC") {
        
        if food == "KFC" {
            print("好吃")
        } else {
            print("想吃KFC")
        }
    }
  	
    //如果协议中方法有mutating关键字，如果结构体来遵守协议则需要mutating
   func changeName(name: String) {
        self.name = name
    }
}
复制代码

如果只希望协议只被类class遵守，只需要在定义协议的时候在后面加上 AnyObject 即可

protocol MYCompatible : AnyObject {
    var name: String {get set}
    ...
}
复制代码

如果协议中定义了构造函数（init），则实现协议的类必须实现这个构造函数

protocol MYCompatible {
    var name: String {get set}
    var birthday: String {get}
    
    // 定义构造函数
    init(name: String)
}
class MYExtension: MYCompatible {
    var name: String = "xiaoma"
    let birthday: String = "1994"
    
    //如果该类被定义为final 则 required 不写  
    required init(name: String) {
    self.name = name    
        
    }
}
复制代码

协议扩展

像上面的例子中 UITableviewCell 和 UICollectionCell 中他们所实现的方法都是一样的，只是两者的类型不同，则没必要定义两个协议，只需要写一个协议即可，这时就可以在协议中使用关联类型 associatedtype

public protocol MYCompatible {
    associatedtype MYCompatibleType
    var my : MYCompatibleType { get }
    
}

final class MYExtension: MYCompatible {
    typealias MYCompatibleType = Bool
    var my: MYCompatibleType {
        return true
    }
}
复制代码

我们知道协议中定义的属性或者方法是不提供实现方式的，我们可以通过协议扩展的形式，在扩展中实现相应的代码：

//定一个协议
public protocol MYCompatible {
    //使用关联类型
    associatedtype MYCompatibleType
    //创建属性 属性类型为关联的协议
    var my : MYCompatibleType { get }
}

//构建一个类，实现协议
public final class MYExtension<Base>: MYCompatible {
    // Base 为泛型
    public let my: Base
    // 构造方法
    public init(_ my:Base) {
        self.my = my
    }
}
复制代码

给协议添加默认实现，用 where 关键字对协议做条件限定（where 类型限定） 这里 MYCompatibleType 关联类型，可以是类或者是结构体，如果是结构体可以用 MYCompatibleType == Data 如果是类则可以 MYCompatibleType: UIView

extension MYCompatible where MYCompatibleType : UIView {
    public var width: CGFloat {
        get {
            return my.frame.size.width
        }
        set {
            my.frame.size.width = newValue
        }
    }
}

在想要扩展的类中添加MYExtension 类或者结构体，这个类是继承MYCompatible的协议的，所以就拥有了MYCompatible协议里面默认的实现方法，即刚才那个用 `where` 限定的类型
extension UIView {
    var my: MYExtension <UIView> {
         return MYExtension(my: self)
    }
}

//调用则是
let view = UIView()
view.my.width = 20
复制代码

我们现在回过头来看看这个扩展协议，首先定义一个名为 MYCompatible 的协议，然后关联类型 associatedtype MYCompatibleType ，定义属性为 var my : MYCompatibleType { get } 返回的类型为关联的类型，再定义一个类 MYExtension <Base> Base为泛型，实现协议，则实现 my 属性，再构造 MYExtension 类的 init 方法，现在对 UIView 进行扩展

extension UIView {
    var my: MYExtension <UIView> {
        return MYExtension(my: self)
    }
}
复制代码

现在 UIView 的对象里的属性 my 就实现了 MYCompatible 协议，即拥有该协议的方法，因为协议默认是不提供方法的实现的，所以要对协议进行扩展，在扩展的时候使用了 where 做类型限定，即方法拥有者只能是限定的类型。

为什么使用协议扩展

因为我们项目里有很多地方是对 UIView 、 UIColor 等常用类进行 extension

1. 在进行多人开发的时候对同一类型做相同操作是很常有的事，他也写了一个和你命名方式一样的方法,但是他也新建了一个文件，然后你们两个方法就冲突了，然后再进行一顿排查。
2. 随着需求的增多，你扩展的方法也就更多，然后将这些方法写成 工具 类，当进行下次开发时可以直接拖进工程中快速使用，但是却与其他人的方法冲突了，很尴尬啊。

上面的协议扩展可以很好的解决这个问题，而且在写法上可以带一个自己的标志，逼格很高。像一些三方库都有这种操作的： view.snp.makeConstraints() 、 imageView.kf.setImage(with: <>)

因为类型很多，要扩展出来的方法也很多，总不能每个类或者结构体都写一个协议吧，其实，写一个就够了，将这些协议抽离出一个通用的即可。demo 中就是这样做的，将协议抽离出一个通用的来。