假设手表扩展中存在xishuai.mp3文件。
let url = Bundle.main.url(forResource: "xishuai", withExtension: "mp3")!
let playAsset = WKAudioFileAsset(url: url)
let playItem = WKAudioFilePlayerItem(asset: playAsset)
player = WKAudioFilePlayer(playerItem: playItem)
WKAudioFilePlayer目前在真机下，如果真机没有连接蓝牙耳机，则播放无声音。因此，不能保证作为通知声音的替代。
Hashable是最常见的协议之一。也许是由于它太常见了。以至于好多人都没法正确的实现它。下面总结一下实现它需要的原则。
基本原则只有两条：
Hashable继承了Equatable。因此，要实现Hashable必须同时实现Equatable。a与b相等时，它们的hashValue相等。反之不成立，即hashValue相等的两个相同类型的a与b，不一定相等。class Fruit:Hashable {
let name:String
var hashValue: Int {
return name.hashValue
}
init(name:String) {
self.name = name
}
static func ==(lhs: Fruit, rhs: Fruit) -> Bool {
return lhs.name == rhs.name
}
}
注意
var hashValue: Int只要求返回值，因此如何实现都可以，设置只返回固定的值，比如var hashValue: Int { return 10 }也是可以的。
不能使用hashValue来判断是否相等。
上面的代码在涉及到子类时，不同的人会有不同的理解。比如：
class Apple:Fruit {
override var hashValue: Int {
return super.hashValue - "apple".characters.count
}
}
class Banana:Fruit {
override var hashValue: Int {
return super.hashValue - "banana".characters.count
}
}
let a = Apple(name: "")
let b = Banana(name: "")
print(a == b) // true
print(a.hashValue) // prints 4799450059485596700
print(b.hashValue) // prints 4799450059485596699
上面的代码，print(a == b) // true，但是hashValue却不相等。这违背了上面提到的基本原则2。这段代码需要修改。但是如何修改，不同的人有不同的看法。
我认为最好的办法就是优先判断类型。因为，类型不同的类，就不应该相等。比如一个苹果就不应该和一个香蕉相等。
class Fruit:Hashable {
let name:String
var hashValue: Int {
return name.hashValue
}
init(name:String) {
self.name = name
}
static func ==(lhs: Fruit, rhs: Fruit) -> Bool {
return type(of:lhs) == type(of:rhs) && lhs.name == rhs.name
}
}
class Apple:Fruit {
override var hashValue: Int {
return super.hashValue - "apple".characters.count
}
}
class Banana:Fruit {
override var hashValue: Int {
return super.hashValue - "banana".characters.count
}
}
let a = Apple(name: "")
let b = Banana(name: "")
print(a == b) // false
print(a.hashValue) // prints 4799450059485596700
print(b.hashValue) // prints 4799450059485596699
即在非final的类的==里，总是先比较类型，类型相同的，再毕竟其它。这么做之后，就永远不会发生一个苹果等于一个香蕉的笑话了。但是这里还有一个问题，我们没有编写子类的==。这里暂时没有问题，但是如果遇到有其它属性的子类，就可能出现问题。
class Orange:Fruit {
let weight:Double
override var hashValue: Int {
return super.hashValue - "orange".characters.count + Int(weight)
}
init(name: String, weight: Double) {
self.weight = weight
super.init(name: name)
}
}
let o1 = Orange(name: "", weight: 0.4)
let o2 = Orange(name: "", weight: 1.2)
print(o1 == o2) // true
print(o1.hashValue) // prints 4799450059485596699
print(o2.hashValue) // prints 4799450059485596700
由于Orange没有重新定义==，比较时，直接调用了Fruit的==，导致了不符合基本原则2。补救办法就是在Orange重新定义==。
class Orange:Fruit {
let weight:Double
override var hashValue: Int {
return super.hashValue - "orange".characters.count + Int(weight)
}
static func ==(lhs: Orange, rhs: Orange) -> Bool {
return type(of:lhs) == type(of:rhs) && lhs.name == rhs.name && lhs.weight == rhs.weight
}
init(name: String, weight: Double) {
self.weight = weight
super.init(name: name)
}
}
let o1 = Orange(name: "", weight: 0.4)
let o2 = Orange(name: "", weight: 1.2)
print(o1 == o2) // false
print(o1.hashValue) // prints 4799450059485596699
print(o2.hashValue) // prints 4799450059485596700
hashValue，仅重新定义==一些特殊的情况下，也许你可以不重写hashValue，而仅重新定义==。
import Foundation
import Cocoa
class Fruit:Hashable {
let name:String
var hashValue: Int {
return name.hashValue
}
init(name:String) {
self.name = name
}
static func ==(lhs: Fruit, rhs: Fruit) -> Bool {
return lhs.name == rhs.name
}
}
class Apple:Fruit {
}
class ColoredApple:Apple {
let color:NSColor
init(name:String, color:NSColor) {
self.color = color
super.init(name: name)
}
static func ==(lhs: ColoredApple, rhs: ColoredApple) -> Bool {
return lhs.name == rhs.name && lhs.color == rhs.color
}
}
let greenApple = ColoredApple(name: "green apple", color: .green)
let apple = Apple(name: "green apple")
print(greenApple == apple) // true
print(greenApple.hashValue) // -2580839601755588497
print(apple.hashValue) //-2580839601755588497
var set:Set<Apple> = [greenApple, apple]
print(set.count) // 1
var d:Dictionary<Apple, Int> = [greenApple:10]
// eat one
d.updateValue(d[greenApple]! - 1, forKey: apple)
print(d[greenApple]!) // 9
这种做法不常见，一旦选择了不重写hashValue，就必须在该基类的所有子类都保持一致。
注意
由于Set和Dictionary使用
hashValue进行判断，放入其中的元素的hashValue在没有从其中移出时，不能改变，否则会出现问题。
可以看到apple和greenApple因为hashValue相同，它们在Set和Dictionary里被当做是同一元素/键值。
在讲解Self之前，需要先简短介绍一下type(of:)的用法。
type(of:)从Xcode 8 beta 6开始，dynamicType被替换为了type(of:)。(SE-0096)
type(of:)的功能是获得实例在运行时（runtime）的元类型（meta type）。这个在之前的Swift里，被称作是dynamicType，与静态的类型进行区别。
SelfSelf是一个特殊的类型。它是self对应的类型。而self是动态类型。比如：
class Foo {
func printType() {
print(type(of:self))
}
func printSelf() {
print(self)
}
}
class Bar:Foo {
}
let foo = Foo()
foo.printType() // Foo
foo.printSelf() // Foo
let bar = Bar()
bar.printType() // Bar
bar.printSelf() // Bar
var test = Foo()
test.printType() // Foo
test.printSelf() // Foo
test = Bar()
test.printType() // Bar
test.printSelf() // Bar
可以看到，self始终对应的是实际类型，无论变量的类型是Foo还是Bar。
由于这个特性的存在，这使得Self无法从静态类型进行转换，而只能通过self来生成。即：
class Foo {
func bar() -> Self {
return self
}
}
class Foo1 {
func bar1() -> Self {
return type(of:self).init()
}
required init() { }
}
注意
Foo1中，有一个
required init()，这是type(of:self).init()必须的。
Self的使用有以下方式：
这是最常见的使用方式。
protocol Foo {
func instance() -> Self
}
class Bar: Foo {
func instance() -> Self {
return self // Declaration: let `self`: Self
}
func other() {
let i = self // Declaration: let `self`: Bar
}
}
class otherBar:Foo {
func instance() -> Self {
return type(of:self).init()
}
required init() { }
}
####注意
Bar中的实现协议的函数里，self是Self类型。而非Self返回值的函数里，self是所在类的类型。
可以使用type(of:self).init()，获得一个新的Self实例。此时，类中必须要有一个required init()。
Self作为函数的返回值的类型时，可以直接写在类中，而不必非要有协议。
下面2和3中的情形，使用associateType的效果，要好于Self。因此，1是Self的最常用的方式。
protocol Foo {
func bar(b:Self)
}
class Bar:Foo {
func bar(b:Bar) {
print(b)
}
}
####注意
Bar中的func bar(b:Bar)是Bar而不是Self。但是这满足协议。这也符合类的多态，即Bar的子类可以调用这个函数。
protocol Foo {
var bar:Self { get set }
}
final class Bar:Foo {
var bar: Bar
init(b:Bar) {
self.bar = b
}
}
####注意
在协议的属性里使用Self时，类必须时final类。
###参考文献：
以下参考文献的一些代码针对的是3.0版本之前的Swift。部分内容需要修正才能运行。但基本原理是相同的。
Types and meta types in swift
Swift中你应该知道的一些有用的tips
Generic Protocols & Their Shortcomings 这篇难度较高，慎看。
Self in Protocol and class method