Jason's Blog

Introducing JCCloudProgressView

2019-05-08T00:39:42.000Z

JCCloudProgressView is a gorgeous progress indicator that you wish your internet could be slower.

During my recent iOS app development, I am working on a project that needs to send large images to our server for image processing.

The data transferring could be slow if our customers are under a pool quality internet environment. We wish this boring process could be pleasing for our customers, so we focused a little bit more on our UI designs.

JCCloudProgressView

If you like it, you can find it on Cocoapods.org and my GitHub page.
https://cocoapods.org/pods/JCCloudProgressView
https://github.com/JasonHan1990/JCCloudProgressView

Feel free to point out any coding errors. I love to learn from you guys.
Thanks!!

My first chrome extension - College Data Scraper

2019-03-29T06:08:46.000Z

I wrote a chrome extension to scrape college admission data.

Recently, I am working on a project about training a model to predict the result of college admission. Me and my teammate, we are searching for data from https://www.collegedata.com. Unfortunately, the website doesn’t offer data downloading. So I started to write a program to scrape the data.
My first implementation was using Cheerio (https://github.com/cheeriojs/cheerio), a NodeJS framework that is good at parsing and searching HTML nodes.
However, I need to hand typing a bunch of variables as inputs to my program. And for my teammate, it was not convenient for him to use. He needed to install NodeJS and know some basic knowledge of how NodeJS works.

My second implementation was to create a chrome extension and use jQuery to scrape the data. Then, I packed the extension and sent it to my teammate to install and use it.

Since it is not a commercial extension. I was keeping things simple.

Files

manifest.json: All the configuration of your extension.
content.js: My code that creates UI and scrapes the data.
FileSaver.js: Use it to save the data as a file. (https://github.com/eligrey/FileSaver.js/)

manifest.json

{
    "manifest_version": 2,
    "name": "Collegedata-Srcaper",
    "version": "0.1",
    "content_scripts": [
        {
          "matches": [
            "https://www.collegedata.com/*"
          ],
          "js": ["jquery-3.3.1.min.js","FileSaver.js", "content.js"]
        }
    ],
    "browser_action": {
        "default_icon": "icon.png"
    }
}

For “js” section, the order is important. Chrome loads them sequentially. So, the libs need to load first.

Install and pack your extension

Go to chrome -> extension. Toggle the developer mode. Then load unpacked extention.

Screenshots

After installing the extension, in the https://www.collegedata.com website, a floating bar appears on the top left corner.

The extension works when there are data on the page. Otherwise, it just alerts you “No data found”.

So, go the admission tracking page, and type in the university and years that you want to look at. Here, I typed in Stanford, and year from 2010 to 2020.

Once the data are retrieved from server. Click “Download” button. Then, save the data.csv file to your desktop.

Open with Office Excel.

Bravo!!!

Link to the code: https://bitbucket.org/JunchengHan/collegedata-scraper-extension/src

Correctly using custom fonts in XCode

2019-03-20T22:27:42.000Z

There are several steps needed before you can successfully use your custom fonts in your iOS app.

Step 1:

Drag your fonts into XCode project, and make sure each of them is included in the target

Step 2:

Double check that your fonts are in the Resource Bundle
Select your target -> Build Phases -> Copy Bundle Resources

Step 3:

Add your fonts to application plist

Step 4:

Check the fonts names
The font file downloaded from internet might be differ from the font name itself. You can check the font name with following codes:
Objective-C

for (NSString * fontFamilyName in UIFont.familyNames) {
    NSLog(@"%@", fontFamilyName);
    for (NSString * fontName in [UIFont fontNamesForFamilyName:fontFamilyName]) {
        NSLog(@"|-%@", fontName);
    }
}

Swift

for family in UIFont.familyNames.sorted() {
    let names = UIFont.fontNames(forFamilyName: family)
    print("Family: \(family) Font names: \(names)")
}

Step 5:

Finally, use your custom fonts.

unsafe_unretained vs. weak

2019-03-03T21:17:39.000Z

They are both representing the nonowning relationship.
But the diffrence is:

When the unsafe_unretained object is recycled by ARC, the property is still pointing to the object. If we are calling the property, the system will crash.
However, when the weak object is recycled by ARC, the property will be set to nil. If we are calling the property, of course nothing will happen, but the system won’t crash.
That is why weak is safer than unsafe_unretained.

CaseIterable from Swift 4.2

2019-02-07T07:02:34.000Z

The new CaseIterable protocol gives your Enum new ability to generate an array of all cases in an enum.

Pasta example from https://www.hackingwithswift.com/articles/77/whats-new-in-swift-4-2

enum Pasta: CaseIterable {
case cannelloni, fusilli, linguine, tagliatelle
}

for pasta in Pasta.allCases {
print(pasta)
}

Print out:

cannelloni
fusilli
linguine
tagliatelle

Then you can easily generate data for table view.

enum Pasta: CaseIterable {
    case conchiglie, fusilli, linguine, tagliatelle
    
    var name: String {
        switch self {
        case .conchiglie: return "Conchiglie"
        case .fusilli: return "Fusilli"
        case .linguine: return "Linguine"
        case .tagliatelle: return "Tagliatelle"
        }
    }
    
    var shape: String {
        switch self {
        case .conchiglie: return "Shells"
        case .fusilli: return "Twists"
        case .linguine: return "Long and skinny"
        case .tagliatelle: return "Long ribbons"
        }
    }
    
    var image: UIImage {
        switch self {
        case .conchiglie: return UIImage(named: "conchiglie")!
        case .fusilli: return UIImage(named: "fusilli")!
        case .linguine: return UIImage(named: "linguine")!
        case .tagliatelle: return UIImage(named: "tagliatelle")!
        }
    }
}

// Generate data for the table view
var objectsForTableView: [Pasta] = Pasta.allcases
...

Here is the pasta table:

AVCapturePhotoSettings Reuse Error

2018-10-17T03:15:54.000Z

The error message when you reused an AVCapturePhotoSettings object is -[AVCapturePhotoOutput capturePhotoWithSettings:delegate:] Settings may not be re-used'.

From apple’s documents.

Important
It is illegal to reuse a AVCapturePhotoSettings instance for multiple captures. Calling the capturePhoto(with:delegate:) method throws an exception (invalidArgumentException) if the settings object’s uniqueID value matches that of any previously used settings object.
To reuse a specific combination of settings, use the init(from:) initializer to create a new, unique AVCapturePhotoSettings instance from an existing photo settings object.

The correct way to do it is to make a new AVCapturePhotoSettings object from copying your pre-made object:

1 2	AVCapturePhotoSettings *uniqueSetting = [AVCapturePhotoSettings photoSettingsFromPhotoSettings:self.outputSettings]; [self.imageOutput capturePhotoWithSettings:uniqueSetting delegate:self];

Blog moving notice

2018-09-18T02:36:10.000Z

I am starting to move my previous blog and project page from Squrespace to Github page starting today. All posts will keep the same publishing date as before. After finishing moving, I will link my personal domain www.junchenghan.com to this Github page.

Thanks.

《iOS面试之道》阅读笔记（3）

2018-08-30T02:45:36.000Z

直接跳到Swift语言吧。Swift很快很安全，而且就我的感受来说，写Swift有一种写脚本语言的快感。但是Swift还有很多路要走，现在最感到头疼的就是和ObjC的混编吧。

Swift

我在这里就按照书中的顺序来做个笔记和添加我所知道的更多知识。

Class和Struct和Enum

对于Class和Struct，一个是引用类型，一个是值类型我就不赘述了，书里写的很清楚。

先说说Struct：

默认下Struct内部的函数是不能修改Struct内部的属性（properties）的，但是我们可以在func前面加mutating关键字来打破默认。例如下面的doSomethingToInternalProperties()。

struct TV {
    var height: Float
    var width: Float
    static var Tag = "electronics"
    
    var diagonals: Int {
      // calculated here
      return result
    }
  
    var spaceTaken: Double {
      get {
        // calculate here
        return result
      }
      set {
        height = Double(newValue)
      }  
    }
    
    mutating func doSomethingToInternalProperties() {
        // do something
    }
}

上面的例子里一共有三种不同的属性（properties）。

height和width是实例属性（instance properties）。这种属性存储了关于一个实例的信息，如高和宽的具体数值。
diagonals是计算属性（Computed Propertie）。这种属性其实根本就不存储任何值，它只是提供了一个getter或者setter让你直接获取一些计算后的值或直接修改实例属性。
Tags是类属性，开头要用static关键字。即不需要创建实例就能获得的关于这个类的属性。let tvTag = TV.Tag

然后Enum：

个人感觉Swift的Enum真的很强大啊，可以有不同的case，也可以有func。Enum和Struct很相似，就不赘述了。我们体验Enum的强大吧，下面是用Enum做一个数学表达式，然后用Enum内部的函数来求值。

// example
indirect enum Expression {
  case number(Int)
  case add(Expression, Expression)
  
  func evaluate() -> Int {
    switch self {
    case let .number(value):
      return value
    case let .add(left, right):
      return left.evaluate() + right.evaluate()
    }
  }
}

var first = Expression.number(50)
var second = Expression.number(12)
var sum = Expression.add(first, second)
second.evaluate() // 12
first.evaluate() // 50
sum.evaluate() // 62

解释一下，这里定义了一个数学表达式Expression的Enum。数学表达式有很多很多中，这里我写了：

代表一个整数的表达式number(Int)
和加法表达式add(Expression, Expression)，之所以括号里面的类型是Expression，是因为它不仅可能是两个整数相加，也可能是两个相加的表达式在求和，类似于（1 + 2）+ 3。

然后内部有一个求值的方程，他会判断，如果这个表达式是一个整数表达式，那么就返回整数的值，如果是加法表达式，这里用到递归，左边表达式求值后再加上右边表达式的值。

你看的没错，Enum里面可以用递归嵌套。这是因为有递归嵌套，所以Enum前面需要加上indirect关键字。

最后Class：

对比与Struct的区别，一个是传递的值得类型不同，另一个是Struct中的属性（properties）是可以不初始化的，就像上面的列子里，height和width我都没有初始化，甚至这两个属性我都没有定义为optional。

但是Class中的属性是要定义的，如果你不定义，那么你多半会得到Class ‘XXX’ has no initializers这样的错误警告。例子：

// Compiler error: Class 'Address' has no initializers
class Address {
    var street: String
}

// you can solve by these ways
// add a init function
class Address {
    var street: String
    
    init(street: String) {
      self.street = street
    }
}

// init the street by default
class Address {
    var street: String = ""
}

// set street to optional
class Address {
    var street: String?
}

Class作为对象当然是可以继承的。一个类继承另一个类后，可以覆盖（override）它父类func的实现方法。如果你不希望子类获得这样的能力，你可以在父类的func前面加上final关键字。Swift不允许类的多继承。

在Swift里面，比较推荐用protocal来代替继承，因为继承会增加程序见的耦合度，增加程序出错的可能性。用protocal的话，就是底耦合度，protocal类似于Java的interface，protocal提供所需的属性和方法，但不实现他们。这些属性和方法由遵循（comfirm）该协议的类来实现。

我看书的目录有关于面向协议的编程一节，这里就不多说了，看到那一节在说。

Optional：

简单理解，就是定义一个value能不能是空的（nil）。一般用if let else或是guard let else来判断。

用guard比if let的好处在于，可以减少if else的嵌套。

Protocol协议：

Swift中的协议真的用法很灵活，大家做好多看看官方Swift教科书。这里列出一些：

Class，Struct，Enum都可以遵循Protocal。你也可以通过在protocal前面加@objc或是在protocal后加class来强制只有Class能用这个Protocal

@objc protocol SomeProtocal {
}

// 或者

protocol SomeProtocal: class {
}

protocal可以定义特定的初始化方法。Class在实现这类初始化方法时，前面要加require。

protocol SomeProtocal {
    var aVar: Int { get set }
    init()
}

class SomeClass: SomeProtocal {
    
    var aVar: Int
    
    required init() {
        aVar = 7
    }
    
    init(_ aVar: Int) {
        self.aVar = aVar
    }
}

struct SomeStruct: SomeProtocal {
    var aVar: Int
    init() {
        aVar = 7
    }
}

protocal可以作为一个类来成为（protocal as type）：
- 一个方程的返回值类型
- 一个值和属性的类型
- 数组，字典或者其他容器中存储值得类型

protocol Vehicle {
}

struct Car: Vehicle {
}

struct Bike: Vehicle {
}

let car = Car(), bike = Bike()
var vehicles : [Vehicle] = [car, bike]

// 更多：类型判定
vehicles.forEach { v in
    if v is Car {
        print("I'm a car")
    } else if v is Bike {
        print("I'm a bike")
    }
}

一个class或struct可以继承多个协议。
默认下，继承协议的class和struct必须实现协议中的所有属性和方法。但是可以通过转化Swift协议到ObjC协议来增加optional。

@objc protocol SomeProtocal {
    @objc optional func someMethod() -> Int
    @objc optional var someProperty: Int { get }
}

代理（Delegation）不是协议（Protocal），它是iOS中的一种设计模式，但是依赖于协议这个技术。用代理的好处在于，委托方不会知道代理方的任何内部情况，通过协议，委托方制定代理方需要实现的功能，然后委托方按照协议实现功能就好了。代理是可以传递消息的，它也是iOS种的一种消息传递方式（其他有：通知NSNotification，Block或Closure，target action，KVO）。

泛型Generic：

书里面简单介绍的Swift泛型怎么用。在实际运用的时候，我们也可以限制泛型值的类型。看个例子，下面的方程返回泛型数组中一个特定值的下标。

func findIndex(of valueToFind: T, in array:[T]) -> Int? {
    for (index, value) in array.enumerated() {
        if value == valueToFind {
            return index
        }
    }
    return nil
}

这段程序是有问题的，因为不是所有类型的值都能使用==来判断相等，特别是工程师自己写的类。只有满足实现了Equatable协议的Class和Struct，程序才能正常运行。所以我们可以对泛型T做限制。

func findIndex(of valueToFind: T, in array:[T]) -> Int? {
    // same as above
}

// 或者用where关键字
func findIndex(of valueToFind: T, in array:[T]) -> Int? where T: Equatable {
    // same as above
}

Open vs. Public

open

open 修饰的 class 在 Module 内部和外部都可以被访问和继承
open 修饰的 func 在 Module 内部和外部都可以被访问和重载（override)

public

public 修饰的 class 在 Module 内部可以访问和继承，在外部只能访问
public 修饰的 func 在 Module 内部可以被访问和重载（override）,在外部只能访问

Copy-on-write

Swift将很多ObjC中的数据类型从引用类（reference type）改成了值类（value type）。这样及降低了内存泄露的风险，也提高了内存效率。书中给了一个例子：

// arrayA 是一个数组，为值类型
let arrayA = [1, 2, 3]
// arrayB 这个时候与 arrayA 在内存中是同一个东西，内存中并没有生成新的数组
let arrayB = arrayA
// arrayB 被修改了，此时 arrayB 在内存中变成了一个新的数组，而不是原来的 arrayA
arrayB.append(4)

然后说到，当arrayB没有改变的时候，arrayB和arrayA指向同一个内存。意思就是他们应该有相同的address。

然后我就像去证明一下，首先通过看官方文献我找到了这样一个方程来返回地址withUnsafePointer(to:_:)。

var array1: [Int] = [0, 1, 2, 3]
var array2 = array1

withUnsafePointer(to: &array1) {
    print(" 1 has address: \($0)")
}
withUnsafePointer(to: &array2) {
    print(" 2 has address: \($0)")
}

// 输出：
// 1 has address: 0x000000011aabf4d0
// 2 has address: 0x000000011aabf4d8

结果输出地址不一样，我当时就很怀疑人生，然后翻看一些书籍和别人的博客寻求答案。我看到的各种东西都证明《iOS面试之道》里是正确的，但是证明呢？

接着我看到了这个方法，用UnsafeRawPointer。

func print(address o: UnsafeRawPointer ) {
    print(String(format: "%p", Int(bitPattern: o)))
}

var array1: [Int] = [0, 1, 2, 3]
var array2 = array1

print(address: array1) //0x60c00006f4a0
print(address: array2) //0x60c00006f4a0

终于得到了相同的地址。那么UnsafeRawPointer和UnsafePointer的区别是什么，我的理解是，UnsafeRawPointer是指向没有类型（untyped）的数据，可以理解为存在内存中裸的数据，例子中就是0在内存中所在位置，而UnsafePointer是指向有类型（typed）的数据，例子中应该是指向我们建立的Array在内存中的地址。

static methods vs. class methods

static 和 class都是用来指定类方法
class关键字指定的类方法可以被 override
static关键字指定的类方法不能被 override

as? vs. as!

这个属于Swift的类型转换（type cast）。

as? - 表示这个类型转换过程是optional的。被赋予的值肯定是一个optional的值。如果类型转换失败，返回nil。
as! - 表示这个类型转换过程不是optional的. System will crash if down casting fails.如果类型转换失败，程序崩溃。

加了些我知道的，但是书里没有提及的知识，先这么多吧，我以前的笔记挺乱的，整理好了有什么要加的在加进来。

Reference：
https://xiaozhuanlan.com/ios-interview 故胤道长和唐巧两位大神的书《iOS 面试之道》
https://swiftdoc.org/
https://developer.apple.com/documentation/swift/unsaferawpointer

《iOS面试之道》阅读笔记（2）

2018-08-29T02:16:24.000Z

栈和队列

栈Stack，后进先出（LIFO）。Swift没有现成的Stack，但是可以用Array来轻松实现。

在iOS面试之道里面，所有不同数据类型的Stack的创建是遵循一个Stack Protocol，然后用Associated Types
来设定不同的数据类型。这非常Swifty。这里也可以用Swift自带的Generic来做：

struct Stack<Element> {
    var store = [Element]()
    
    var size: Int {
        return store.count
    }
    
    var peek: Element? {
        return store.last
    }
    
    mutating func push(_ item: Element) {
        store.append(item)
    }
    mutating func pop() {
        store.removeLast()
    }
}

var intStack = Stack<Int>()
intStack.push(1)

队列Queue，先进先出（FIFO）。同样也可以用Array来实现。

struct Queue<Element> {
    var store = [Element]()
    
    var size: Int {
        return store.count
    }
    
    var isEmpty: Bool {
        return store.count == 0
    }
    
    mutating func enqueue(_ e: Element) {
        store.append(e)
    }
    
    mutating func dequeue() -> Element? {
        return store.first
    }
}

var queue = Queue<Int>()

简单解释用两个Stack实现一个Queue。假设我们有StackA和StackB，StackA用来存Enqueue进来的元素，StackB用来处理Dequeue的元素。

Enqueue：直接把新的元素放进StackA
Dequeue：
1. 如果StackB是空的，则把StackA中的所有元素dequeue出来然后enqueue进StackB中，这个时候，之前最先进去StackA的元素就到了StackB的顶部，然后就只需要dequeue出StackB里的一个元素返回。
2. 如果StackB中不是空，就直接dequeue然后返回。

用两个Queue实现Stack要稍微难想一点点，要点事两个Queue要shift他们的功能。

更多：

如何实现一个线程安全的Stack。实现线程安全在iOS中有多种方法，主要分为运用锁（lock）相关的技术和运用线程先关的技术。在阅读苹果关于多线程编程的文档后，可以得知，苹果官方推荐工程师用线程相关的技术，特别是GCD，来做线程安全。原因是因为：iOS系统分为应用层（application level）和内核层（kernel level）。锁的处理是在内核层，当程序每一次创建锁和开锁的时候，它都要从应用层转到内核层进行操作，这个过程的消耗是巨大的，更不用说在用锁实现线程安全的时候会有大量的建锁和开锁的程序。而苹果的GCD则不同，它基本上是只运行在应用层的，只有真正有需要的时候，才会进去内核层。

再来说说CGD做线层安全，我所知道的有两个方法：

用串行队列（Serial dispatch queue）的方法
用并行队列（Concurrent dispatch queue）+ 栅栏（Barrier）的方法

我以前一直认为第二种方法更高效，毕竟是并发嘛。但是在和一个苹果工程师交谈后和阅读苹果文档后，我发现了问题所在。在用第二种方法的时候，程序会创建Barrier和删除Barrier，情形类似于锁，这个过程会消耗很多性能。如果这个线程安全的Stack有大量的数据操作的话，自然就慢了。

看了这么多，其实苹果官方文档中有这个一句话：

Serial dispatch queue offer a more efficient alternative to locks and other synchronization primitives.

意思就是串行最棒棒。所以我为什么之前要讲这么多。

给个例子吧，这个是我以前写的Thread Safe Stack，虽然是用ObjC，但是可以看看。这里我是用LinkList来实现Stack。所有的程序都是ObjC，不过更优秀的做法是用C或C++来写LinkList。

ListNode.h

#import 

@interface ListNode : NSObject <NSSecureCoding>

@property (nonatomic, strong, nullable) id value;
@property (nonatomic, strong, nullable) ListNode *next;

- (nullable instancetype)initWithValue:(nullable id)value andNext:(nullable ListNode *)next;

@end

ListNode.m

#import "ListNode.h"

@implementation ListNode

- (instancetype)init
{
    self = [super init];
    if (self) {
        self.next = NULL;
        self.value = NULL;
    }
    return self;
}

- (instancetype)initWithValue:(id)value andNext:(ListNode *)next {
    self = [super init];
    if (self) {
        self.next = next;
        self.value = value;
    }
    return self;
}

#pragma mark - NSCoding

#define kValueKey @"valueKey"
#define kNextKey @"nextKey"

- (void)encodeWithCoder:(nonnull NSCoder *)aCoder {
    [aCoder encodeObject:_value forKey:kValueKey];
    [aCoder encodeObject:_next forKey:kNextKey];
}

- (nullable instancetype)initWithCoder:(nonnull NSCoder *)aDecoder {
    id value = [aDecoder decodeObjectForKey:kValueKey];
    id next = [aDecoder decodeObjectOfClass:[ListNode class] forKey:kNextKey];
    
    self = [super init];
    
    if (self) {
        self.value = value;
        self.next = next;
    }
    return self;
}

+ (BOOL)supportsSecureCoding {
    return YES;
}

@end

ThreadSafeStack.h

#import 

@protocol ThreadSafeStackProtocol

- (void)test;

@end

@interface ThreadSafeStack<__covariant ObjectType> : NSObject <NSSecureCoding, NSMutableCopying, NSCopying>

// MARK: initializer
- (instancetype)init;

// MARK: public motheds
- (void)push:(ObjectType)object;
- (ObjectType)pop;
- (ObjectType)peek;


@property (nonatomic, weak) id delegate;
@property (nonatomic, strong) NSArray<id> * array;

@property (readonly) NSUInteger count;

@end

ThreadSafeStack.m

#import "ThreadSafeStack.h"
#import "ListNode.h"

@interface ThreadSafeStack()

@property (nonatomic, strong) ListNode *head;
@property (nonatomic, strong) dispatch_queue_t isolationQueue;

@end

@implementation ThreadSafeStack

- (instancetype)init {
    self = [super init];
    if (self) {
        _head = NULL;
        NSString *name = [NSString stringWithFormat:@"com.ThreadSafeStack.dispatchQueue.%@", [[NSUUID UUID] UUIDString]];
        _isolationQueue = dispatch_queue_create([name cStringUsingEncoding:NSASCIIStringEncoding], DISPATCH_QUEUE_SERIAL);
    }
    return self;
}

#pragma mark - setter and getter

- (NSUInteger)count {
    __block NSInteger res = 0;
    dispatch_sync(self.isolationQueue, ^{
        ListNode *temp = self.head;
        while (temp != NULL) {
            res += 1;
            temp = temp.next;
        }
    });
    return res;
}

#pragma mark - public methods

- (id)peek {
    __block id res;
    dispatch_sync(self.isolationQueue, ^{
        res = self.head.value;
    });
    return res;
}

- (id)pop {
    __block id res = NULL;
    dispatch_sync(self.isolationQueue, ^{
        if (self.head == NULL) {
        } else {
            res = self.head.value;
            self.head = self.head.next;
        }
    });
    return res;
}

- (void)push:(id)object {
    dispatch_async(self.isolationQueue, ^{
        self.head = [[ListNode alloc] initWithValue:object andNext:self.head];
    });
}

#pragma mark - override methods

- (NSString *)description {
    NSMutableString *des = [NSMutableString stringWithFormat:@"%@: ", [super description]];
    dispatch_sync(self.isolationQueue, ^{
        ListNode *temp = self.head;
        while (temp != NULL) {
            [des appendString:[NSString stringWithFormat:@"%@ ", [temp.value description]]];
            temp = temp.next;
        }
    });
    return [des copy];
}

#pragma mark - NSCopy and NSMutableCopy

- (id<NSCopying, NSSecureCoding>)copyWithZone:(NSZone *)zone {
    ThreadSafeStack *copy = [[[self class] allocWithZone:zone] init];
    copy.head = self.head;
    return copy;
}

- (id)mutableCopyWithZone:(NSZone *)zone {
    return [self copyWithZone:zone];
}

#pragma mark - NSCoding

#define kHeadKey @"headKey"

- (void)encodeWithCoder:(nonnull NSCoder *)aCoder {
    [aCoder encodeObject:_head forKey:kHeadKey];
}

- (nullable instancetype)initWithCoder:(nonnull NSCoder *)aDecoder {
    id head = [aDecoder decodeObjectOfClass:[ListNode class] forKey:kHeadKey];
    
    self = [super init];
    if (self) {
        _head = head;
        NSString *name = [NSString stringWithFormat:@"com.ThreadSafeStack.dispatchQueue.%@", [[NSUUID UUID] UUIDString]];
        _isolationQueue = dispatch_queue_create([name cStringUsingEncoding:NSASCIIStringEncoding], DISPATCH_QUEUE_SERIAL);
    }
    return self;
}

+ (BOOL)supportsSecureCoding{
    return YES;
}

Reference:

https://xiaozhuanlan.com/ios-interview 《iOS 面试之道》

Concurrency programming / GCD
https://developer.apple.com/documentation/dispatch
https://developer.apple.com/library/content/documentation/General/Conceptual/ConcurrencyProgrammingGuide/Introduction/Introduction.html\#//apple\_ref/doc/uid/TP40008091-CH1-SW1

Threading
https://developer.apple.com/library/content/documentation/Cocoa/Conceptual/Multithreading/Introduction/Introduction.html\#//apple\_ref/doc/uid/10000057i-CH1-SW1

《iOS面试之道》阅读笔记（1）

2018-08-27T21:37:42.000Z

数据结构

Array

关于Swift的数组，有三种不同的形式：

ContiguousArray: 其实我之前也一直没有注意这个形式的数组，因为平时更多在写Objc，很少写Swift。ContiguousArray就是强制规划一个连续的空间来储存Elements。当用ContiguousArray来储存对象数据（class或@objc）时，其性能优于Array。
Array: 当Array储存值类型的数据的时候，内存空间是连续的。但是当储存类型是对象（class或@objc）的时候，Array会自动桥接到NSArray上，内存可能不连续。其实可以看出，当Array和ContiguousArray都储存值类型（struct或enumeration）的话，他们的性能相当。
ArraySlice: 数组片段，它的作用就是让我们更快和更高效地对一个大数组的其中一部分最处理。ArraySlice是不会创建新的存储空间的，它和原本的Array在内存上共享同一区域。但是，这并不意味修改ArraySlice中的元素会影响到原来的Array。

1 2	var cArray = ContiguousArray<Any>(repeating: 0, count: 3) print(type(of: cArray)) // "ContiguousArray\n"

Array的`count`和`capacity`：

我们知道，当Array中的元素增加的时候，如果数组的内存不足，就需要新建一个更大的数组，然后从旧的数组中复制所有元素到新的数组里。现在的高级语言的Array都是Dynamic Array，你不需要自己去给数组扩容。为了提高数组扩的容的效率，底层代码都是成倍数的增加数组的大小。如Swift的Array的增长因子是2（阅读）。所以Capacity和Count是不同的，Capacity是指这个数组的总大小，Count是现在所有存在元素的个数。例子：

var cArray = ContiguousArray<Any>(repeating: 0, count: 3)
print(cArray.count)        // 3
print(cArray.capacity)     // 3

cArray.append(9)
print(cArray.count)        // 4
print(cArray.capacity)     // 6

// 当removeAll的时候，数组的所有空间都会被释放掉
cArray.removeAll()        
print(cArray.count)        // 0
print(cArray.capacity)     // 0

Array的`reserveCapacity(_:)`：

正如上面所说，当数组扩容的时候是有性能损耗的。当你大概知道需要多大内存容量的数组的时候，就可以用reserveCapacity(_:)来创建和保持数组的大小，省去数组Capacity变化带来的性能损耗。

ArraySlice的index并不总是开始于0：

ArraySlice会保留在原本数组中相同元素的index。

let absences = [0, 2, 0, 4, 0, 3, 1, 0]

let midpoint = absences.count / 2
//
let firstHalf = absences[..
let secondHalf = absences[midpoint...]

firstHalf[0]    // 0
secondHalf[0]   // Fatal error: Index out of bounds

ArraySlice会持有一个对原数组的强应用：

这意味着可能存在的内存溢出。在Swift文档中有如下建议：

Important: Long-term storage of ArraySlice instances is discouraged. A slice holds a reference to the entire storage of a larger array, not just to the portion it presents, even after the original array’s lifetime ends. Long-term storage of a slice may therefore prolong the lifetime of elements that are no longer otherwise accessible, which can appear to be memory and object leakage.

Set And Dictionary

Set和Dictionary在查找上都是O(1)，这是源于他们都采用了hash。他们在存储时都是无序的。如果你有需求将一个自定义的类放入Set中或作为Dictionary的Key，那么这个类需要满足Hashable Protocal。

Dictionary的value可以为nil吗：

可以的。当你在创建一个dictionary的时候，如果value为nil，则这个字典中所有的value都会转化为optional。
另外，我们知道在Swift中去删除一个Key-Value pair，我们只需要给这个key所对应的value赋值nil。那么当value为nil时，这个方法会不会失效？答案是不会。
最后，当一个value是nil的时候，用if let判断时会怎样？答案是if let会通过，value为nil。例子：

var dic = ["a": 1,
           "b": nil,
           "c": 3]

var dicA = ["a": 1,
            "b": 2,
            "c": 3]
            
print(dic)     // ["b": nil, "a": Optional(1), "c": Optional(3)]
print(dicA)    // ["b": 2, "a": 1, "c": 3]

// if let
if let valueFromB = dic["b"] {
    print("b has value: \(valueFromB)")
} else {
    print("b has no value")
}

// 输出: b has value: nil

// 删除b
dic["b"] = nil
print(dic)     // ["a": Optional(1), "c": Optional(3)]

String

对比与Objective-C，swift把很多类都变成了struct，字符串也不例外。这样的好处是增加了代码的安全，因为Swift为你最好了Copy-on-write，你也不用再像写ObjC那样要特别留意用copy关键字和动不动就要copy一下。当然，通过用inout关键字也是能实现传递引用的。

获得所有字符：

用一个Array来获得一个所有字符的数组。

1 2	let string = "abc" // "abc" let chars = Array(string) // ["a", "b", "c"]

subString：

String和Array很像，当你计算出一个range后，你就可以获得子字符串。

let fqdn = "useyourloaf.com"
let tldEndIndex = fqdn.endIndex
let tldStartIndex = fqdn.index(tldEndIndex, offsetBy: -3)
let range = Range(uncheckedBounds: (lower: tldStartIndex, upper: tldEndIndex))
fqdn[range]    // "com"

“From https://useyourloaf.com/blog/swift-string-cheat-sheet/”

Reference:
https://xiaozhuanlan.com/ios-interview 《iOS 面试之道》
https://useyourloaf.com
https://swiftdoc.org/

AVPlayer - AVFoundation

2017-08-22T02:37:17.000Z

AVPlayer

AVFoundation provides a controller class AVPlayer to play timed audio-visual media. The AVPlayer can handle playback of local, progressively downloaded and streamed media conforming HLS protocol.

AVPlayer is just a controller. It can play, pause, stop and jump to a certain time in a video, but it can’t show a video to users’ eyes. In order to display the video in user interface, we need use AVPlayerLayer.

AVPlayerLayer

AVPlayerLayer is built on the top of Core Animation. AVPlayerLayer extends the CALayer class, so it can be used like any other CALayer and can be set as the backing layer for UIView or NSView or can be added into an existing layer hierarchy.
AVPlayerLayer has a property videoGravity to specifies how the video is displayed within a player layer’s bounds.

typedef NSString * AVLayerVideoGravity NS_STRING_ENUM;

/*!
    @constant       AVLayerVideoGravityResizeAspect
    @abstract       Preserve aspect ratio; fit within layer bounds.
 */
AVF_EXPORT AVLayerVideoGravity const AVLayerVideoGravityResizeAspect NS_AVAILABLE(10_7, 4_0); // default


/*!
    @constant       AVLayerVideoGravityResizeAspectFill
    @abstract       Preserve aspect ratio; fill layer bounds.
 */
AVF_EXPORT AVLayerVideoGravity const AVLayerVideoGravityResizeAspectFill NS_AVAILABLE(10_7, 4_0);

/*!
    @constant       AVLayerVideoGravityResize
    @abstract       Stretch to fill layer bounds.
 */
AVF_EXPORT AVLayerVideoGravity const AVLayerVideoGravityResize NS_AVAILABLE(10_7, 4_0);

AVPlayerItem

AVPlayerItem stores the reference to AVAsset objects. AVPlayerItem is a dynamic object. Many of its property values can be changed during the item’s preparation and playback. We can use KVO to observe these changes as they occur. For instance, the AVPlayerItem has a property status to indicate if the item is ready for playback. When you first create a player item, the status is AVPlayerItemStatusUnknown, meaning it’s not ready for playback. We need to wait until its status changes to AVPlayerItemStatusReadyToPlay before it’s ready to use.

Creating AVPlayer

// Example for create an avplayer
@property (strong, nonatomic) AVPlayer * player;
@property (strong, nonatomic) AVPlayerItem * playerItem;

- (void)initPlayer:(NSURL *)url {
  
  // Create AVAsset
  AVAsset *asset = [AVAsset assetWithURL:url];
  
  // Create an avplayer item with asset
  playerItem = [AVPlayerItem playerItemWithAsset:asset];
  
  // register KVO for observing the change of status
  NSKeyValueObservingOptions options =
        NSKeyValueObservingOptionOld | NSKeyValueObservingOptionNew;
  
  [playItem addObserver:self 
             forKeyPath:@"status" 
                options:options 
                context:&PlayerItemContext];
  
  // create avplayer with player item
  self.player = [AVPlayer playerWithPlayerItem:playerItem];
  
  // create a player layer to display video content
  AVPlayerLayer *playerLayer = [AVPlayerLayer playerLayerWithPlayer:self.player];
  
  // add player layer to current view hierarchy
  [self.view.layer addSublayer:playerLayer];
}

- (void)observeValueForKeyPath:(NSString *)keyPath
                      ofObject:(id)object
                        change:(NSDictionary<NSString *,id> *)change
                       context:(void *)context {
    // Only handle observations for the PlayerItemContext
    if (context != &PlayerItemContext) {
        [super observeValueForKeyPath:keyPath ofObject:object change:change context:context];
        return;
    }
 
    if ([keyPath isEqualToString:@"status"]) {
        AVPlayerItemStatus status = AVPlayerItemStatusUnknown;
        // Get the status change from the change dictionary
        NSNumber *statusNumber = change[NSKeyValueChangeNewKey];
        if ([statusNumber isKindOfClass:[NSNumber class]]) {
            status = statusNumber.integerValue;
        }
        // Switch over the status
        switch (status) {
            case AVPlayerItemStatusReadyToPlay:
                // Ready to Play
                break;
            case AVPlayerItemStatusFailed:
                // Failed. Examine AVPlayerItem.error
                break;
            case AVPlayerItemStatusUnknown:
                // Not ready
                break;
        }
    }
}

Manage Playback Time

CMTime is the structure describing media time. A CMTime is represented as a rational number, with a numerator (an int64_t value), and a denominator (an int32_t timescale).

typedef struct{    
    CMTimeValue    value; // think as the total number of frames
    CMTimeScale    timescale; // think as the frame per second
    CMTimeFlags    flags;      
    CMTimeEpoch    epoch;
} CMTime;

AVPlayerItem has a duration property which is a object of CMTime. We can get the total duration in seconds by

double seconds = playerItem.duration.value / playerItem.duration.timescale;

// or
double seconds = CMTimeGetSeconds(playerItem.duration)

We can create a CMTime by CMTimeMake(int64_t value, int32_t timescale)

1 2	CMTime t1 = CMTimeMake(1, 10); // 0.1s CMTime t2 = CMTimeMake(2, 1); // 2s

AVPlayer has this functions to manage the time.

/* Returns the current time of the current player item. */
- (CMTime)currentTime;

/* Sets the current playback time to the time specified by the date object.
 */
- (void)seekToDate:(NSDate *)date;

/* Sets the current playback time to the specified time and executes the specified block when the seek operation completes or is interrupted. */
- (void)seekToDate:(NSDate *)date completionHandler:(void (^)(BOOL finished))completionHandler NS_AVAILABLE(10_7, 5_0);

/* Sets the current playback time to the specified time. */
- (void)seekToTime:(CMTime)time;

/* Sets the current playback time within a specified time bound. */
- (void)seekToTime:(CMTime)time toleranceBefore:(CMTime)toleranceBefore toleranceAfter:(CMTime)toleranceAfter;

/* Sets the current playback time to the specified time and executes the specified block when the seek operation completes or is interrupted.
 */
- (void)seekToTime:(CMTime)time completionHandler:(void (^)(BOOL finished))completionHandler NS_AVAILABLE(10_7, 5_0);

/* Sets the current playback time within a specified time bound and invokes the specified block when the seek operation has either been completed or been interrupted.
 */
- (void)seekToTime:(CMTime)time toleranceBefore:(CMTime)toleranceBefore toleranceAfter:(CMTime)toleranceAfter completionHandler:(void (^)(BOOL finished))completionHandler NS_AVAILABLE(10_7, 5_0);

Observing time

AVPlayer also provides methods for us to observing time.

/* Requests the periodic invocation of a given block during playback to report changing time. */
- (id)addPeriodicTimeObserverForInterval:(CMTime)interval queue:(nullable dispatch_queue_t)queue usingBlock:(void (^)(CMTime time))block;

/* Requests the invocation of a block when specified times are traversed during normal playback. */
- (id)addBoundaryTimeObserverForTimes:(NSArray<NSValue *> *)times queue:(nullable dispatch_queue_t)queue usingBlock:(void (^)(void))block;

/* Cancels a previously registered periodic or boundary time observer. */
- (void)removeTimeObserver:(id)observer;

For example, we can add update the player transport UI by adding a periodic time observer.

// update transport UI
- (void)addPeriodicTimeObserver {
    // Invoke callback every half second
    CMTime interval = CMTimeMakeWithSeconds(0.5, NSEC_PER_SEC);
    // Queue on which to invoke the callback
    dispatch_queue_t mainQueue = dispatch_get_main_queue();
    // Add time observer
    __weak typeof(self)WeakSelf = self;
    self.timeObserverToken =
        [self.player addPeriodicTimeObserverForInterval:interval
                                                  queue:mainQueue
                                             usingBlock:^(CMTime time) {
                                                 // Use weak reference to self
                                                 // Update player transport UI
                                                 float currentPlayTime = (float)item.currentTime.value/ item.currentTime.timescale;
                                                 [WeakSelf updateTransportBar:currentPlayTime];
                                             }];
}

- (void)dealloc {
  [_player removeTimeObserver:_timeObserverToken];
}

Handle Playback End

AVPlayerItem has several notifications for different activities.

AVPlayerItemTimeJumpedNotification
AVPlayerItemDidPlayToEndTimeNotification
AVPlayerItemFailedToPlayToEndTimeNotification
AVPlayerItemPlaybackStalledNotification
AVPlayerItemNewAccessLogEntryNotification
AVPlayerItemNewErrorLogEntryNotification

We can use these to track current playback. For handling playback end:

// Add Observer
[[NSNotificationCenter defaultCenter] addObserver:self
                                         selector:@selector(handlePlayerDidFinishPlaying:)
                                             name:AVPlayerItemDidPlayToEndTimeNotification
                                           object:[self.player currentItem]];
                                           
- (void)handlePlayerDidFinishPlaying:(NSNotification *)notification {
    AVPlayerItem *playerItem = (AVPlayerItem *)notification.object;
    
    // Jump to the beginning of the video
    [playerItem seekToTime:kCMTimeZero];
    // pause the video
    [player pause];
}

Handle Interruption

When AVPlayer got interrupted, current playback will pause. We can listen to the notification comes from AVAudioSession, but don’t forget to activate AVAudioSession.

// Configure AVAudioSession and activate it when you init your avplayer controller
// Setup audio session catagory, use playback for video playback
AVAudioSession *session = [AVAudioSession sharedInstance];
        
NSError *error;
if (![session setCategory:AVAudioSessionCategoryPlayback error:&error]) {
    NSLog(@"Category Error: %@", [error localizedDescription]);
}
        
if (![session setActive:YES error:&error]) {
    NSLog(@"Activation Error: %@", [error localizedDescription]);
}


// Add Observer
[[NSNotificationCenter defaultCenter] addObserver:self
                                         selector:@selector(handleSessionInterruption:)
                                             name:AVAudioSessionInterruptionNotification
                                           object:nil];
                                           
- (void)handleSessionInterruption:(NSNotification *)notification {
    AVAudioSessionInterruptionType type = [notification.userInfo[AVAudioSessionInterruptionTypeKey] unsignedIntegerValue];
    if (type == AVAudioSessionInterruptionTypeBegan) {
    
        // pause the video
        [self.player pause];
        
    } else if (type == AVAudioSessionInterruptionTypeEnded) {
        // resume the video ??
    }
}

Handle Route Change

We will use the notification comes from AVAudioSession again to handle route change.

// Add Observer
[[NSNotificationCenter defaultCenter] addObserver:self
                                         selector:@selector(handleRouteChange:)
                                             name:AVAudioSessionRouteChangeNotification
                                           object:nil];
                                           
- (void)handleRouteChange:(NSNotification *)notification {
    
    AVAudioSessionRouteChangeReason reason = [notification.userInfo[AVAudioSessionRouteChangeReasonKey] unsignedIntegerValue];
    
    if (reason == AVAudioSessionRouteChangeReasonOldDeviceUnavailable) {
        AVAudioSessionRouteDescription *preRoute = notification.userInfo[AVAudioSessionRouteChangePreviousRouteKey];
        NSString *portType = [[preRoute.outputs firstObject] portType];
        if ([portType isEqualToString:AVAudioSessionPortHeadphones]) {
            // This notification was send from other thread, pop up error message under main thread
            dispatch_async(dispatch_get_main_queue(), ^{
                // pause the video
                [self pause];
            });
        }
    }
}

Handle Fail Play To End

AVPlayerItemFailedToPlayToEndTimeNotification. In most cases, we will get this notification when we play streaming video and you got network problem.

// Add Observer
[[NSNotificationCenter defaultCenter] addObserver:self
                                         selector:@selector(handleAVPlayerItemFailedToPlayToEndTime:) 
                                             name:AVPlayerItemFailedToPlayToEndTimeNotification
                                           object:nil];
                                           
- (void)handleAVPlayerItemFailedToPlayToEndTime:(NSNotification *)notification {
    NSError *error = notification.userInfo[AVPlayerItemFailedToPlayToEndTimeErrorKey];
    
    // This notification was send from other thread, pop up error message under main thread
    dispatch_async(dispatch_get_main_queue(), ^{
        [self popErrorAlert:error];
    });
}

Here is the Test App

AVAssets - AVFoundation

2017-08-22T01:43:54.000Z

AVAsset is an abstract, immutable class providing a composite representation of a media resource, modeling the static attributes of the media as a whole, such as its title, duration, and metadata. AVAsset is not the media itself, but acts as a container for timed media. It is composed of one or more media tracks along with metadata describing its contents.

AVAsset confirms the AVAsynchronousKeyValueLoading protocol. We can querying an asset’s properties asynchronously.

// check for status for a key
- (AVKeyValueStatus)statusOfValueForKey:(NSString *)key error:(NSError * _Nullable * _Nullable)outError;
// asynchronously load properties by given keys 
- (void)loadValuesAsynchronouslyForKeys:(NSArray<NSString *> *)keys completionHandler:(nullable void (^)(void))handler;

// example 
// Load the asset's "playable" key
[asset loadValuesAsynchronouslyForKeys:@[@"playable"] completionHandler:^{
    NSError *error = nil;
    AVKeyValueStatus status =
        [asset statusOfValueForKey:@"playable" error:&error];
    switch (status) {
        case AVKeyValueStatusLoaded:
            // Successfully loaded, continue processing
            break;
        case AVKeyValueStatusFailed:
            // Examine NSError pointer to determine failure
            break;
        case AVKeyValueStatusCancelled:
            // Loading cancelled
            break;
        default:
            // Handle all other cases
            break;
    }
}];

Note that:
The completionHandler block will be called only once per invocation of loadValuesAsynchronouslyForKeys:completionHandler:, no matter how many keys you pass to this methods.
We need to call status statusOfValueForKey:error: on each property you requested.

https://developer.apple.com/documentation/avfoundation/avasset

AVAudioRecorder - AVFoundation

2017-08-16T21:38:24.000Z

AVAudioRecorder is also built on top of Audio Queue Services. It provides capability to:

Record until user stop the recording
Record for a specified duration
Pause and resume recording
Audio-level metering

For recording and playback, we should choose AVAudioSessionCategoryPlayAndRecord for AVAudioSession category.
In order to use the microphone on our device, we need add microphone usage key to application.plist file.

1 2	<key>NSMicrophoneUsageDescriptionkey> <string>Need to use the microphone to recordstring>

Create AVAudioRecorder

To create an AVAudioRecorder, we need a url to specify a location to record to, a dictionary of settings for the recording session and output error.

1	- (instancetype)initWithURL:(NSURL )url settings:(NSDictionary<NSString ,id> )settings error:(NSError _Nullable *)outError;

Configure recording session

We can configure several different things for our recording session. The general settings are audio data format, sampling rate and number of channels.

NSMutableDictionary *setting = [NSMutableDictionary dictionary];
/* set format 
** Note: the audio format we specify must be compatible with the tpye defined in the url argument. For example,
** .wav pairs to kAudioFormatLinearPCM
** .aac .m4a pair to kAudioFormatMPEG4AAC
** .alac pairs to kAudioFormatAppleLossless
*/
[setting setValue:@(kAudioFormatMPEG4AAC) forKey:AVFormatIDKey];
/* set sampling rate
** Standard sampling rate for audio: 8kHz, 16kHz, 22.05kHz, 44.1kHz
*/
[setting setValue:@(16000.0) forKey:AVSampleRateKey];
/* set channal
** 1 is for single channel, 2 is for stereo
*/
[setting setValue:@(1) forKey:AVNumberOfChannelsKey];

// example for creating a AVAudioRecorder
// create store url
NSString *urlString = [NSSearchPathForDirectoriesInDomains(NSDocumentDirectory, NSUserDomainMask, YES) objectAtIndex:0];
NSDate *now = [NSDate date];
NSDateFormatter *dateFormatter = [[NSDateFormatter alloc] init];
[dateFormatter setDateFormat:@"yyyyMMddHHmmssSSS"];
urlString = [urlString stringByAppendingFormat:@"%@-MySound.acc", [dateFormatter stringFromDate:now]];
NSURL *url = [NSURL fileURLWithPath:urlString];

// set audio recording setting
NSMutableDictionary *setting = @{
  AVFormatIDKey: @(kAudioFormatMPEG4AAC),
  AVSampleRateKey: @(16000.0),
  AVNumberOfChannelsKey: @(1)
}

NSError *error;

AVAudioRecorder *recorder = [[AVAudioRecorder alloc] initWithURL:url settings:setting error:&error];

if (recorder) {
  // configure recorder
} else {
  // output the error
}

Controlling Recording

/* when we call this method, the program creates an audio file at the location specified by the url we created */
- (BOOL)prepareToRecord;

/* all record methods will implicitly call prepareToRecord() */
- (BOOL)record;
- (BOOL)recordAtTime:(NSTimeInterval)time;
- (BOOL)recordForDuration:(NSTimeInterval) duration;
- (BOOL)recordAtTime:(NSTimeInterval)time forDuration:(NSTimeInterval) duration;

- (void)pause;
- (void)stop;
/* This method can't be called before the audio recorder stoped */
- (BOOL)deleteRecording;

Audio Level Metering

Like AVAudioPlayer, the metering is not enabled by default.

@property(getter=isMeteringEnabled) BOOL meteringEnabled;
- (void)updateMeters;

- (float)peakPowerForChannel:(NSUInteger)channelNumber;
- (float)averagePowerForChannel:(NSUInteger)channelNumber;

Handle Interruption

Pause the recording by your audio session got interrupted.

[[NSNotificationCenter defaultCenter] addObserver:self 
                                        selector:@selector(handleInterruption:) 
                                            name:AVAudioSessionInterruptionNotification 
                                          object:nil];
                                          
- (void)handleInterruption:(NSNotification *)notification {
    AVAudioSessionInterruptionType type = [notification.userInfo[AVAudioSessionInterruptionTypeKey] unsignedIntegerValue];
    
    if (type == AVAudioSessionInterruptionTypeBegan) {
        [self.recorder pause];
    }
}

Audio file Saving and deleting

AVAudioRecorder needs a place to store the recording audio file. It is a good practice that store the audio file in the temporary directory in iOS file system during recording, and then copy the file to documents directory for permanent saving.

/* Create temperary url */
NSString *tmpPath = NSTemporaryDirectory();
tmpPath = [tmpPath stringByAppendingPathComponent:@"record.caf"];
NSURL *tmpURL = [NSURL fileURLWithPath:tmpPath];
// ...

/* When saving the audio */
// create destination url for audio file
// use timestamp to be the unique id
NSTimeInterval timestamp = [NSDate timeIntervalSinceRefernceDate];
NSString *fileName = [NSString stringWithFormat:@"%@-%f.caf", audioName, timestamp];

// get documents directory path
NSStirng *docPath = [NSSearchPathForDirectoriesInDomains(NSDocumentDirectory, NSUserDomainMask, YES) objectAtIndex:0];
NSString *destPath = [docPath stringByAppendingPathComponent:fileName];
NSURL destURL = [NSURL fileURLWithPath:destPath];

// use NSFileManager to copy the file
NSError *error;
if (![[NSFileManager defaultManager] copyItemAtURL:tmpURL toURL:destURL error:&error]）{
    NSLog(@"%@", [error localizedDescription]);
}

/* delete audio file */
NSError *error;
BOOL success = [[NSFileManager defaultManager] removeItemAtURL:audioFileURL error:&error];
if (!success) {
     NSLog(@"Unable to delete: %@", [error localizedDescription]);
}

Test app is Here.

AVFoundation Developer Guide

AVAudioPlayer - AVFoundation

2017-08-15T21:03:50.000Z

AVAudioPlayer makes easy to playback the audio data from local files and memory. It is built on top of Core Audio’s C-based Audio Queue Service. It provides all core functions we can find in Audio Queue Service.

Things that AVAudioPlayer can’t do:

Play audio from a network stream
Access the raw audio sample
Require very low latency

Create AVAudioPlayer

The AVAudioPlayer can be created by NSData or NSURL.

// Initializer for AVAudioPlayer
- (nullable instancetype)initWithContentsOfURL:(NSURL *)url error:(NSError **)outError;
- (nullable instancetype)initWithData:(NSData *)data error:(NSError **)outError;

// Example: 
// A function to create an AVAudioPlayer with local audio file name and its extension
- (AVAudioPlayer *)playerFileName:(NSString *)name withExtension:(NSString *)extension {
    NSURL *fileURL = [[NSBundle mainBundle] URLForResource:name withExtension:extension];
    NSError *err;
    AVAudioPlayer *player = [[AVAudioPlayer alloc] initWithContentsOfURL:fileURL error:&err];
    
    // Configure the player
    if (player) {
        player.numberOfLoops = -1; // infinite loop
        player.enableRate = YES;
        [player prepareToPlay];
    } else {
        NSLog(@"%@", [err localizedDescription]);
    }
    
    return player;
}

Controlling Playback

AVAudioPlayer provides ways for us to modify the player’s volume, panning, playback rate, number of looping and preform audio metering.
Calling play() will play a sound asynchronously. It will implicitly call the prepareToPlay() if the audio player is not already prepared to play. We can call the prepareToPlay() method after we created a audio player to minimize the lag between calling the play() method. Calling stop() method will stop the playback and undo the setup from prepareToPlay().

/* set the audio player’s stereo pan position, value from -1.0 to 1.0. A value of -1.0 is full left, 0.0 is center, 1.0 is full right. */
@property float pan;

/* set the audio player’s volume, value from 0.0 to 1.0. */
@property float volume;

/* set the audio player’s playback rate. Default value is 1.0, value 0.5 is half-speed playback, 2.0 is double-speed playback. To set playback rate, we need to enable rate adjustment. */
@property float rate;
/* default is NO */
@property BOOL enableRate;

/* set number of times a sound will return to the beginning to repeat playback. Default value is 0, play once, a value of 1 plays twice, a negative value will play infinitely */
@property NSInteger numberOfLoops;

- (BOOL)prepareToPlay;
- (void)play;
- (BOOL)playAtTime:(NSTimeInterval)time;
- (void)pause;
- (void)stop;

Audio Level Metering

AVAudioPlayer doesn’t meter the audio-level by default. We can turn it on and get average sound decibel and peak decibel.

/* default is not enabled */
@property(getter=isMeteringEnabled) BOOL meteringEnabled; 

/* Refreshes the average and peak power values for all channels of an audio player. For best results, call this function in CADisplayLink */
- (void)updateMeters; 
- (float)peakPowerForChannel:(NSUInteger)channelNumber; 
- (float)averagePowerForChannel:(NSUInteger)channelNumber;

Configure AVAudioSession

In order to make our app playback sound when we lock the screen or we turn our cellphones to silent mode, we need to choose the correct AVAudioSessionCategory to AVAudioSession.
AVAudioSession is a global singleton instance. We can configure it after app launched. There are several categories. https://developer.apple.com/documentation/avfoundation/avaudiosession/audio_session_categories

Category	Allows Mixing	Audio Input	Audio Output	When Screen Lock	When Silent
Ambient	yes	no	yes	off	off
Solo Ambient	no	no	yes	off	off
Playback	optional	no	yes	on	on
Record	no	yes	no	on	on
Play and Record	optional	yes	yes	on	on
Multi-Route	no	yes	yes	on	on

// Configure AVAudioSession
AVAudioSession *session = [AVAudioSession sharedInstance];

NSError *error;
// use AVAudioSessionCategoryPlayback to make the app playback sound when screen locked and silent turned on
if (![session setCategory:AVAudioSessionCategoryPlayback error:&error]) {
    NSLog(@"Category Error: %@", [error localizedDescription]);
}
    
if (![session setActive:YES error:&error]) {
    NSLog(@"Activation Error: %@", [error localizedDescription]);
}

In order to make the app play in the background, we also need change the info.plist file. Add following code to the file.

<key>UIBackgroundModeskey>
<array>
    <string>audiostring>
array>

Adding this setting specifies that the application is now allowed to play audio in the background.

Handle Interruption

When we got a call or alarm, our app will automatically pause the sound, but it will not play the sound after the interruption. We can listen the AVAudioSessionInterruptionNotification notification and code the behavior we want.

// add notification for audio player controller
[[NSNotificationCenter defaultCenter] addObserver:self
                                        selector:@selector(handleInterruption:)
                                           name:AVAudioSessionInterruptionNotification
                                         object:[AVAudioSession sharedInstance]];
                                         
- (void)handleInterruption:(NSNotification *)notification
{
    AVAudioSessionInterruptionType type = [notification.userInfo[AVAudioSessionInterruptionTypeKey] unsignedIntegerValue];
    if (type == AVAudioSessionInterruptionTypeBegan) {
        // do something when interruption began
    }else if (type == AVAudioSessionInterruptionTypeEnded) {
        // do something when interruption ended
    }
}

Handle Route Change

When we switch the audio output route, iOS will send a route change notification. Suppose we want to stop the playback when users unplug their headphone, we can check the notification’s userInfo dictionary for the route change reason and for a description of the previous audio route. If previous portType is AVAudioSessionPortHeadphones, we stop the playback.

// Note This is not calling from main thread
[[NSNotificationCenter defaultCenter] addObserver:self
                                        selector:@selector(handleRouteChange:)
                                            name:AVAudioSessionRouteChangeNotification
                                          object:[AVAudioSession sharedInstance]];

- (void)handleRouteChange:(NSNotification *)notification {
    
    AVAudioSessionRouteChangeReason reason = [notification.userInfo[AVAudioSessionRouteChangeReasonKey] unsignedIntegerValue];
    if (reason == AVAudioSessionRouteChangeReasonOldDeviceUnavailable) {
        AVAudioSessionRouteDescription *preRoute = notification.userInfo[AVAudioSessionRouteChangePreviousRouteKey];
        NSString *portType = [[preRoute.outputs firstObject] portType];
        if ([portType isEqualToString:AVAudioSessionPortHeadphones]) {
            // stop the playback
        }
    }
}

AVAudioPlayer Delegate

// Called when audioplayer finished playing.
- (void)audioPlayerDidFinishPlaying:(AVAudioPlayer *)player successfully:(BOOL)flag;
// Called when an audio player encounters a decoding error during playback.
- (void)audioPlayerDecodeErrorDidOccur:(AVAudioPlayer *)player error:(NSError *)error;

Here is the link for the test app: AVAudioPlayer Test App

Screenshot

AVFoundation Developer Guide

Swift Refreshing

2017-08-08T05:38:44.000Z

This is the note for swift knowledge refreshing.

TYPES:

All types are named with UpperCamelCase. All variables are named with lowerCamelCase.
- Types: Bool, Int, String, Character… or MyType
- Variables: num: Int, isTrue: Bool…
Type conversion:
- type name(value): Double(10)
- as keyword: let doubleVal = 3 as Double

TUPLES:

When to use a tuple? For shortly operation, like sending multiple values to a function or return multiple values from a function. Otherwise, using struct or class.

let coordinate: (Stirng, Int, Int) = ("Coordinate" , 3, 5)
// assign tuples
var (label, x, y) = coordinate
// use _ to disregard one value
var (_, x, y) = coordinate

// access to the value in tuple
let coordinate: (Stirng, Int, Int) = ("Coordinate" , 3, 5)
// use index
coordinate.0 // "Coordinate"
coordinate.1 // 3
coordinate.2 // 5

// or name the value
let coordinate_1 = (name: "Coordinate", x: 3, y: 4)
// use name
coordinate_1.name // "Coordinate"
coordinate_1.x // 3
coordinate_1.y // 5

LOOP:

var count = 0

// while loop
// print: 0...3
while count < 4 {
  connt += 1
}

count = 0
// repeat while
// print: 1
repeat {
  count += 1
} while count > 100

// for loop
for index in 0..<4 {
  
}

// skip one loop 
continue

// leave the loop
break

SWITCHING:

// if you want to fall through the switch case, use fallthrough keyword
switch variable {
  case value:
    // case code
    fallthrough
  default:
    // default code
}

// case can be a range
let choosed = 2
switch choosed {
  case 0...3:
    print("You choosed a value between 0 to 3")
  default:
    break
}

// case can be multiple value
let name = "Jason"
switch name {
  case "Jason", "John":
    print("You meet Jason and John.")
  default:
    break
}

// tuple can use swich statement
let north = 0, south = 1, east = 2, west = 3
let movement = (north, 100)
switch movement {
  case (south, _):
    print("You move to south.")
  case (_, 100):
    print("You move at 100 miles per hour.")
  default:
    break
}

// tuple case can be variables
switch movement {
  case let (direction, speed) where speed >= 100:
    print("You are overspeed.")
  default:
    break
}

DICTIONARY:

Dictionary return optional.
Assign nil to delete key pair.
Iterate the dictionary
- for (key, value) in dictionary {}
- for key in dictionary.keys {}
- for val in dictionary.values {}

STRUCTURE:

By default, methods in struct can’t mutate the internal variables, because the struct is immutable. But we can label the method to mutating to do the job.

1
2
3

mutating func doSomethingToInternalVal() {
  // do something
}

Properties:

struct TV {
  var height: Double
  var width: Double
  var diagonals: Int {
    // calculated here
    return result
  }
  
  var spaceTaken: Double {
    get {
      // calculate here
      return result
    }
    set {
      height = Double(newValue)
    }  
  }
}

properties: height and width. These can be accessed and mutated.
computed properties: diagnonal. These are read only.
getter and setter: get and set keywords in a computed property. For setter, we have a newValue keyword to get the setting value.
type properties: static properties. We don’t need a instance to get this property, just call the type and reference the property.

CLASS:

When we created an object with “let”, we assigned a constant reference to that variable. You can not assign a new object to it, but you can still change its properties.

Class need initializer when at least one of its properties is not initialed or nil.

// Compiler error: Class 'Address' has no initializers
class Address {
    var street: String
}

// you can solve by these ways
// add a init function
class Address {
    var street: String
    
    init(street: String) {
      self.street = street
    }
}

// init the street by default
class Address {
    var street: String = ""
}

// set street to optional
class Address {
    var street: String?
}

INHERITANCE:

final keyword can prevent one class or function been inherited.

INITIALIZERS:

Designated initializer need to make sure all none optional properties has a value.
Convenience initializer must call designated initializer, however you can set some default values for some properties.
When calling parent’s initializer, we use super.init(). In swift, we call parent’s initializer after we init all properties in child’s class. This prevents a property been used before it is ready. And more important, we can only call the parent’s designated initializer but not convenience initializer.

PROTOCOL:

Property Requirements

A protocol can require any confirming type to provide an instance property or type property. It only specifies the required property name and type and also specifies whether each property must be gettable or gettable and settable.

protocol SomeProtocol {
  var mustBeSettable: Int { get set }
  var doesNotNeedToBeSettable: Int { get }
}

Always prefix type property requirements with the static keyword when you define them in protocol.

1
2
3

protocol AnotherProtocol {
    static var someTypeProperty: Int { get set }
}

Method Requirements

Always prefix type method requirements with the static keyword when you define them in protocol.

1
2
3

protocol SomeProtocol {
    static func someTypeMethod()
}

Always prefix mutating method requirements with the mutating keyword when you define them in protocol to indicate that method is allowed to modify the instance it belongs and to any properties of that instance.

When a class confirmed the protocol with mutating method, we don’t need to put mutating keyword before the func. The mutating keyword is only used by structures and enumerations.

protocol Togglable {
  mutating toggle()
}

enum LightSwitch: Togglable {
  case on, off
  
  mutating toggle() {
    switch self {
      case .on:
        self = .off
      case .off:
        self = .on
    }
  }
}

Protocol can require specified initializer to be implemented by confirming types. When confirming types implement the initializer, put required keyword before init. If a subclass overrides a designated initializer from a superclass, and also implements a matching initializer requirement from a protocol, mark the initializer implementation with both the required and override modifiers.

protocol SomeProtocal {
  init()
}

class SomeSuperClass {
  init() {
    // init implementation
  }
}

class SomeSubClass: SomeSuperClass, SomeProtocol {
  // "required" from SomeProtocol conformance; "override" from SomeSuperClass
  required override init() {
    
  }
}

Protocol as type

As a parameter type or return type in a function, method, or initializer
As the type of a constant, variable, or property
As the type of items in an array, dictionary, or other container

Delegation:

Delegation is a design pattern that enable a class or structure to hand off some of its responsibilities to an instance of another type. The delegation pattern is implemented by:

Define an protocol which contains all delegated responsibilities.
A type confirms the protocol to guarantee to provide all delegated responsibilities.

Delegation can respond to a particular action, or retrive data from an external source without understanding the type of the source.

Protocol Inheritance:

Protocol can inherit one or more other protocols and add further requirements.

Class-only Protocol

We can limit the protocol adoption to class type by adding class keyword after colon.

Optional requirements

Both the protocol and the optional requirement must be marked with the @objc attribute.
Note that @objc protocols can be adopted only by classes that inherit from Objective-C classes or other @objc classes.

@objc protocol CounterDataSource {
    @objc optional func increment(forCount count: Int) -> Int
    @objc optional var fixedIncrement: Int { get }
}

CUSTOM OPERATORS:

Overloading an existing operator: To overloading an operator, define a new function for the operator symbol.

// Use * to repeat a string a specified number of times
// use extension to set what type of variable can use this operator
extension String {
  static func *(lhs: String, rhs: Int) -> String {
    guard rhs > 0 else {
      return ""
    }
    var res = left
    for _ in 0..<right - 1 {
      res += left
    }
    return res
  }
}

"a" * 6
// "aaaaaa"

Custom a new operator: A custom operator needs three things.

Define its precedence
Define its associativity: left, right or none.
Define whether its prefix, in fix or postfix

// create exponential operator **
// custom precedence group
precedencegroup ExponentiationPrecedence {
  higherThan: MultiplcationPrecedence
  associativity: none // none make the programmer use parenthsis
}

// define the operator
infix operator **: ExponentiationPrecedence

// function
func **(base: Double, exponent: Double) -> Double {
  return pow(base, exponent)
}

GENERICS

Define generics:

To make your function or type to be generic, add placeholder type name inside angle brackets.

// example
func swapTwoValues(_ a: inout T, _ b: inout T){
  let temp = a
  a = b
  b = temp
}

struct Stack<Element> {
  var store = [Element]()
  mutating func push(_ item: Element) {
    store.append(item)
  }
  mutating func pop() {
    store.removeLast()
  }
}

var stackOfInt = Stack<Int>()
stackOfInt.push(1)

Extending a generic type

When we extend a generic type, we don’t need to provide the type parameter in extension definition.

// follow by the generic stack
extension Stack {
  var topItem: Element? {
    return store.last
  }
}

Type constraint syntax

1
2
3

func someFunction(someT: T, someU: U) {
  // function body
}

Example: we have a function which finds the index number for a generic item in an array.

func findIndex(of valueToFind: T, in array:[T]) -> Int? {
    for (index, value) in array.enumerated() {
        if value == valueToFind {
            return index
        }
    }
    return nil
}

We will see one error in the console, because not every Swift type confirmed the protocol Equatable.

1	error: binary operator '==' cannot be applied to two 'T' operands

To solve this problem, we can make a constraint to the generic type T by adding portable Equatable after T:.

1
2
3

func findIndex(of valueToFind: T, in array:[T]) -> Int? {
    // same as above
}

If you want your custom types to use this function, you should make your custom types confirm the protocol Equatable. For example, we make a full name structure, and we have an array of names, find one in it.

// make a FullName structure confirming Equatable protocol
struct FullName: Equatable {
    var firstName: String
    var lastName: String
    
    // Implement the equatable requirement
    static func ==(lhs: FullName, rhs: FullName) -> Bool {
        return lhs.firstName == rhs.firstName && lhs.lastName == rhs.lastName
    }
}

// test
let n0 = FullName(firstName: "Jason", lastName: "Han")
let n1 = FullName(firstName: "Dane", lastName: "Fox")
let n2 = FullName(firstName: "Billy", lastName: "Douglas")
let n3 = FullName(firstName: "Fran", lastName: "Deleon")
let n4 = FullName(firstName: "Carolina", lastName: "Buchanan")
let n5 = FullName(firstName: "Natalee", lastName: "Howe")
let names: [FullName] = [n0, n1, n2, n3, n4, n5]

findIndex(of: FullName(firstName: "Billy", lastName: "Douglas"), in: names)
// output: 2

We can also use where clause to define constraints for type.

// The code above
func findIndex(of valueToFind: T, in array:[T]) -> Int? {
    // same as above
}

// This can be written as
func findIndex(of valueToFind: T, in array:[T]) -> Int? where T: Equatable {
    // same as above
}

Associated Types

An associated type gives a placeholder name to a type that is used as part of the protocol. Assign actual type to that associated type when the protocol is adopted. associatedtype keyword.

// Example we made an associated type Item in protocol container
protocol Container {
  associatedtype Item
  
  mutating func add(_ item: Item)
  var count: Int { get }
  
  subscript(i: Int) -> Item { get }
}

// For a nongeneric type IntStack, we need define the type of Item in IntStack with typealias.
struct IntStack: Container {
  var items = [Int]()

  // Let Swift know the type of Item
  typealias Item = Int
  
  mutating func add(_ item: Int) {
    items.append(item)
  }
  
  var count: Int {
    return items.count
  }
  
  subscript(i: Int) -> Int {
    return items[i]
  }
}

// For a generic type Stack, Swift is smart enough to know the type of the Item.
struct Stack<Element>: Container {
  var elements = [Element]()
  
  mutating func add(_ item: Element) {
        elements.append(item)
    }
    
  var count: Int {
      return elements.count
  }
  
  subscript(i: Int) -> Element {
    return elements[i]
  }
}

More for the where clauses we talked above, it can do more jobs for type constraints. This is a function for checking two containers are equal.

func allItemsMatch
    (_ someContainer: C1, _ anotherContainer: C2) -> Bool
    where C1.Item == C2.Item, C1.Item: Equatable {
        
        // Check that both containers contain the same number of items.
        if someContainer.count != anotherContainer.count {
            return false
        }
        
        // Check each pair of items to see if they are equivalent.
        for i in 0..count {
            if someContainer[i] != anotherContainer[i] {
                return false
            }
        }
        
        // All items match, so return true.
        return true
}

In the where clauses:

C1.Item == C2.Item makes sure C1 and C2 contains same type of item.
C1.Item: Equatable makes sure C1’s item confirming equatable protocol, also C2’s item since we checked two containers has same type of items.

Extension with generic where clause

We can use extension with generic where clause to require the element to confirm to a protocol and also require the element to be specific type.

// Use stack we create above
// We add a function to check whether an element is at the top of stack
extension Stack where Element: Equatable {
  func isTop(_ element: Element) -> Bool {
    guard let topElement = store.last else {
      return false
    }
    return topElement == element
  }
}

// We can specify the element to be double, and calculate the average number of all elements
extension Stack where Element == Double {
  func average() -> Double {
    var sum = 0.0
    for i in 0..count {
      sum += store[i]
    }
    return sum / Double(store.count)
  }
}

SUBSCRIPTS:

Classes, structures, and enumerations can define subscripts, which are shortcuts for accessing the member elements of a collection, list, or sequence.

// Example syntax
subscript(index: Int) -> Int {
    get {
        // return an appropriate subscript value here
    }
    set(newValue) {
        // perform a suitable setting action here
    }
}

For usage, we use [] after the type. Take dictionary as a example,

1
2
3

let numberOfPages = ["The Lord of the Rings" : 900, "The Man Without Qualities" : 289]
numberOfPages["The Man Without Qualities"]
// print 289

NSTimer

2016-11-24T06:09:17.000Z

I will talk about NSTimer in this order.

Initial a NSTimer
Invalidate a NSTimer
NSTimer and runloop

Initial

To initial a NSTimer, apple offers three ways.

1	+ (NSTimer *)scheduledTimerWithTimeInterval:(NSTimeInterval)ti target:(id)aTarget selector:(SEL)aSelector userInfo:(id)userInfo repeats:(BOOL)rep;

This method creates a timer and schedules it on the current run loop in default mode. The concept of the run loop is pretty important in NSTimer. I will talk about it later.

1	+ (NSTimer *)timerWithTimeInterval:(NSTimeInterval)ti target:(id)aTarget selector:(SEL)aSelector userInfo:(id)userInfo repeats:(BOOL)rep;

Compared with the first method, this one creates a timer without scheduling it on the run loop. But NSTimer only works when it is on a run loop. So, in order to make it work, we need to add it to a run loop by calling the addTimer:(NSTimer *)timer forMode:(NSRunLoopMode)mode from NSRunloop.

1	- (instancetype)initWithFireDate:(NSDate *)date interval:(NSTimeInterval)ti target:(id)t selector:(SEL)aSelector userInfo:(id)ui repeats:(BOOL)rep;

Like the second method, this one does schedule the timer on a run loop, but it offers a way to create a fire date for the timer. Don’t forget to add the timer to a run loop by addTimer: forMode:.

Difference between three ways

Invalidate

Before taking about invalidate a NSTimer, let’s us see fire method first.

1	- (void)fire;

This method fires a repeating timer without interrupting its regular firing schedule. If the timer is non-repeating, it is automatically invalidated after firing, even if its scheduled fire date has not arrived.

Even if you didn’t put the timer on the run loop, you can use fire method to cause the receiver’s message to be sent to its target.

For example, with a non-repeated timer, after firing the timer, it will be invalidated. So, you can not fire it again.

A non-repeated timer

The NSLog:

NSLog

Then, with a repeated timer:

A repeated timer

The NSLog:

NSLog

Now, let’s talk about invalidate.

1	- (void)invalidate;

This method is the only way to remove a timer from an NSRunLoop object. Unlike other objects in OC, it is useless to set a timer to nil and let it be destroyed by ARC. The reason is not only the viewController has a strong reference to the timer, but the run loop also has one. When you set _timer = nil, you only break the reference between viewController and timer.

We can simply check the retain count by:

Check retain count

The NSLog:

NSLog

So, to destroy a NSTimer, we usually do:

1 2	[_timer invalidate]; _timer = nil;

and do this before the view is destroyed, not in -(void)deallocNSTimer andrunloop

What is the run loop? A run loop is an abstraction that (among other things) provides a mechanism to handle system input sources (sockets, ports, files, keyboard, touch, timers, etc).

NSTimer must be on a run loop, otherwise, it will not work. By default, NSTimer will be scheduled on run loop with NSDefaultRunLoopMode. There are other modes such as UITrackingRunLoopMode. The problem is when you scroll a scrollView, the timer will stop until the scrolling is over, because the the run loop is working on the UITrackingRunLoopMode, all events on NSDefaultRunLoopMode will stop and wait.

To solve this problem, we can manually add a timer on all common modes. Notice that UITrackingRunLoopMode is also in common modes.

1	[[NSRunLoop currentRunLoop] addTimer:_timer forMode:NSRunLoopCommonModes];

This will guarantee that timer will work, no matter what mode the current run loop is.

Create Thumbnail For Video

2016-11-09T00:18:05.000Z

Here is how to create thumbnail for videos. Two steps:

Use AVURLAsset to access to the video file by URL. Then use AVAssetImageGenerator to generate an image of one frame.
To distinguish the image we generated from normal images, add a play icon on the top of the image by merging two UIImage .

Code:

+ (UIImage *)createVideoThumbnailWithPath:(NSString *)videoPath {
    if (!videoPath)
        return nil;

    AVURLAsset *asset = [[AVURLAsset alloc] initWithURL:[NSURL fileURLWithPath:videoPath] options:nil];
    AVAssetImageGenerator *imgGenerator = [[AVAssetImageGenerator alloc] initWithAsset:asset];
    imgGenerator.appliesPreferredTrackTransform = YES;
    imgGenerator.apertureMode = AVAssetImageGeneratorApertureModeEncodedPixels;

    // create CGImage
    CGImageRef thumbnailImgRef = nil;
    // the time frame
    CFTimeInterval thumbnailImageTime = 0;
    NSError *error = nil;

    // get the image
    thumbnailImgRef = [imgGenerator copyCGImageAtTime:CMTimeMake(thumbnailImageTime, 60) actualTime:nil error:&error];

    // error handling
    if (!thumbnailImgRef)
        NSLog(@"VIDEO THUMBNAIL ERROR: %@", error);

    // convert to UIImage
    UIImage *image = thumbnailImgRef ? [[UIImage alloc] initWithCGImage:thumbnailImgRef] : nil;

    // add playIcon
    if (image) {
        // grab your play icon
        UIImage *playIcon = [UIImage imageNamed:@"PlayIcon"];

        // start image context
        UIGraphicsBeginImageContext(image.size);

        // add original image first with existing opacity
        [image drawInRect:CGRectMake(0,0,image.size.width,image.size.height)];

        // add play icon over the image in the middle with supplied opacity if applicable
        [playIcon drawInRect:CGRectMake((image.size.width - playIcon.size.width) / 2.0,
                                        (image.size.height - playIcon.size.height) / 2.0,
                                        playIcon.size.width,playIcon.size.height)
                   blendMode:kCGBlendModeNormal
                       alpha:0.9];

        // get merged image
        UIImage *newImage = UIGraphicsGetImageFromCurrentImageContext();

        UIGraphicsEndImageContext();

        return newImage;
    }
    return image;
}

Error: Cannot Assign To 'self' Outside Of A Method In The Init Family

2016-11-03T22:37:06.000Z

I got this error because I mistyped the Link to link.

So two rules that Xcode determine a method is an init method:

return instancetype or id
the method name should be a capital letter followed by init.

For example:

1	- (intancetype)initWithImage:(UIImage *)image;

GCD Note 2

2016-10-31T22:14:07.000Z

Continue after GCD Note 1.

dispatch_after

The method dispatch_after works like a delayed dispatch_async. The dispatch_after() function submits the block to the given queue at the time specified by the when parameter.

Example:

dispatch_time_t delay = dispatch_time(DISPATCH_TIME_NOW, 2 * NSEC_PER_SEC);
dispatch_after(delay, dispatch_get_main_queue(), ^{
   //do something on main thread after 2 sec
});

dispatch group

Dispatch group is used to do some updates after a group of tasks. The tasks in the group can be either asynchronous or synchronous. To create a group:

1	dispatch_group_t group = dispatch_group_create();

There are two ways to add tasks to the group. The first way is adding a block of code to the group, and executing on a specified queue like globe queue:

dispatch_group_async(group,specifiedQueue,^{
    // do something 1 here
});
dispatch_group_async(group,specifiedQueue,^{
    // do something 2 here
});
...

But this is not suitable for something you want to have callback straight away.

The second way is to set starting and ending manually by using dispatch_group_enter() and dispatch_group_leaving().

Suppose we need to download an image with its thumbnail and the original image from a server with different URLs.

dispatch_group_t group = dispatch_group_create();
for (NSInteger i = 0; i < 2; i++) {
    NSURL *url;
    switch (i) {
        case 0:
              url = [NSURL URLWithString:thumbnailURLString];
              break;
        case 1:
              url = [NSURL URLWithString:orignalURLString];
              break;
        default:
              break;
     }
    dispatch_group_enter(group);
    UIImage *image = [ImageDownloader alloc] initWithURL: url withCompletion:^(NSError *error) {
        if (error) {
            // handle the error
        }
        dispatch_grounp_leave(group);
    }];

    // store the images some where
}

Notice that the number of enter should be equal to the number of leave.

Then, how to notify that the group is finished. There are also two ways. First one, using dispatch_group_wait().

1 2	dispatch_group_wait(dispatch_group_t group, dispatch_time_t timeout); // do something after group is finished

This method will return a long value if the time expired before all tasks are finished, and it will block the current thread.

The second way is to use dispatch_group_notify():

1
2
3

dispatch_group_notify(dispatch_group_t group, specifiedQueue,^{
    // do something here on the specifiedQueue
});

The dispatch_group_notify() function provides asynchronous notification of the completion of the blocks associated with the group by submitting the block to the specified queue once all blocks associated with the group have completed.

Why strongSelf and weakSelf?

2016-10-26T02:51:16.000Z

Before talking about strongSelf and weakSelf, I need briefly explain retain cycle.

So, a retain cycle usually occurs when an object A has a strong reference to Object B, and Object B also has a strong reference to Object A. Under this situation, the retainCount for both objects can not be 0, so the memory for these two objects won’t be released. This is the memory leak. The retain cycle could happen between multiple objects as long as their references between each other form a cycle.

Retain cycle 1

Also, an object can have a reference of itself which will cause retain cycle too. The most common situation is that an object owns a block, and in the block, we call any of this object’s methods or properties. Then the block has a reference to this object itself, which cause a retain cycle. Notice that blocks maintain strong references to any captured objects, including self, because they don’t want data be destroyed by ARC before themselves getting executed.

Retain cycle 2

Example 1:

I have an object called Car. Car has a block called drive.

// car.h
#import 
typedef void(^Drive)();

@interface Car : NSObject
@property (nonatomic, copy) NSString *miles;
@property (nonatomic, copy) Drive drive;
@end

In the viewController.

#import "ViewController.h"
#import "Car.h"

@interface ViewController ()
@end

@implementation ViewController

- (void)viewDidLoad {
    [super viewDidLoad];

    Car *car = [[Car alloc]init];
    car.miles = @"100 miles";

    car.drive = ^{
        NSLog(@"Car drived %@", car.miles);
    };

    car.drive();
    NSLog(@"return");
}
@end

Leak! Here, the car has a strong reference to the drive block, and in the block, the block has a strong reference to the car since we called car.miles. This made the car has a reference to itself.

Using Instruments to detect the leak. Click the red cross. Malloc 48 Bytes means the system allocate 48 Bytes of memory to the block.

Open Cycles & Roots. You can see the cycle.

no ivar: Instruments can't find the variable name that allocated the memory so you get the [no ivar] message.

Change the Example 1 to Example 2.

Example 2:

I pass a parameter into the block. Leak?

#import "ViewController.h"
#import "Car.h"

@interface ViewController ()
@end

@implementation ViewController

- (void)viewDidLoad {
    [super viewDidLoad];

    Car *car = [[Car alloc]init];
    car.miles = @"100 miles";

    car.drive = ^(NSString *miles){
        NSLog(@"Car drived %@", miles);
    };

    car.drive(car.miles);
    NSLog(@"return");
}
@end

No Leak. Checking the leak with instruments:

Since I pass the car.miles into the block as a parameter, and the block won’t retain the parameter, there will be no retain cycle.

WEAKSELF AND STRONGSELF

weakSelf

How to create a weakSelf? There are two ways.

1 2	__weak __typeof(self) weakSelf = self; // Write this code every time before you use weakself.

1 2	#define WEAKSELF typeof(self) __ weak weakSelf = self // Or create a macro in header file, then you can use WEAKSELF everywhere.

The reason we use weakSelf in a block is that with weak property, the block won’t retain the object in the block. Then we break the cycle. For example 1, we can use weakself to solve the retain cycle problem.

#import "ViewController.h"
#import "Car.h"

@interface ViewController ()
@end

@implementation ViewController

- (void)viewDidLoad {
    [super viewDidLoad];

    Car *car = [[Car alloc]init];
    car.miles = @"100 miles";

    __weak __typeof(car) weakCar = car;
    car.drive = ^{
        NSLog(@"Car drived %@", weakCar.miles);
    };

    car.drive();
    NSLog(@"return");
}
@end

strongSelf

1	__strong __typeof(weakSelf) strongSelf = weakSelf;

1	#define STRONGSELF typeof(weakSelf) __strong strongSelf = weakSelf

Since we use weakSelf in the block to prevent the retain cycle problem, there is a potential problem that the object could be released before the block has been executed.

example 3:

#import "ViewController.h"
#import "Car.h"

@interface ViewController ()
@end

@implementation ViewController

- (void)viewDidLoad {
    [super viewDidLoad];

    Car *car = [[Car alloc]init];
    car.miles = @"100 miles";

    __weak __typeof(car) weakCar = car;
    car.drive = ^{
        dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(2.0 * NSEC_PER_SEC)), dispatch_get_main_queue(), ^{
            NSLog(@"Car drived %@", weakCar.miles);
        });
    };
    car.drive();
    NSLog(@"return");
}
@end

I add a delay before executing the NSlog(). Then the output is:
... 15:28:20.875923 BlockTest[7630:4429580] return... 15:28:23.065725 BlockTest[7630:4429580] Car drived (null)

What is happening here? The dispatch_after() function submits the block (which contains NSLog()) to the given queue (Here is the main queue) at the time specified by the when (Here is after 2 sec) parameter. Think the block as a task. The dispatch_after() asynchronously add the task to the main queue after two sec when you execute the study block. Since the study block has a weak reference to the car, after the study block has been execute (car.drive() is called), the weakCar is released by ARC, then the weak object will be set as nil. However, the dispatch block is still not executed. That is why we got null in the output.

So, we add strongSelf in the block which prevent the object will not be released inside the block. After the block is executed, strongSelf then release.

#import "ViewController.h"
#import "Car.h"

@interface ViewController ()
@end

@implementation ViewController

- (void)viewDidLoad {
    [super viewDidLoad];

    Car *car = [[Car alloc]init];
    car.miles = @"100 miles";

    __weak __typeof(car) weakCar = car;
    car.drive = ^{
        __strong __typeof(weakCar) strongCar = weakCar;
        dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(2.0 * NSEC_PER_SEC)), dispatch_get_main_queue(), ^{
            NSLog(@"Car drived %@", strongCar.miles);
        });
    };

    car.drive();
    NSLog(@"return");
}
@end

Jason's Blog

Introducing JCCloudProgressView

My first chrome extension - College Data Scraper

Files

manifest.json

Install and pack your extension

Screenshots

Bravo!!!

Correctly using custom fonts in XCode

Step 1:

Step 2:

Step 3:

Step 4:

Step 5:

unsafe_unretained vs. weak

CaseIterable from Swift 4.2

AVCapturePhotoSettings Reuse Error

Important

Blog moving notice

《iOS面试之道》阅读笔记（3）

Swift

Class和Struct和Enum

先说说Struct：

然后Enum：

最后Class：

更多：

Optional：

Protocol协议：

泛型Generic：

Open vs. Public

Copy-on-write

static methods vs. class methods

as? vs. as!

《iOS面试之道》阅读笔记（2）

更多数据结构

链表

栈和队列

《iOS面试之道》阅读笔记（1）

数据结构

Array

ContiguousArray的创建：

Array的count和capacity：

Array的reserveCapacity(_:)：

ArraySlice的index并不总是开始于0：

ArraySlice会持有一个对原数组的强应用：

Set And Dictionary

Dictionary的value可以为nil吗：

String

获得所有字符：

subString：

AVPlayer - AVFoundation

AVPlayer

AVPlayerLayer

AVPlayerItem

Creating AVPlayer

Manage Playback Time

Observing time

Handle Playback End

Handle Interruption

Handle Route Change

Handle Fail Play To End

AVAssets - AVFoundation

AVAudioRecorder - AVFoundation

Create AVAudioRecorder

Configure recording session

Controlling Recording

Audio Level Metering

Handle Interruption

Audio file Saving and deleting

AVAudioPlayer - AVFoundation

Create AVAudioPlayer

Controlling Playback

Audio Level Metering

Configure AVAudioSession

Handle Interruption

Handle Route Change

AVAudioPlayer Delegate

Swift Refreshing

TYPES:

TUPLES:

`ContiguousArray`的创建：

Array的`count`和`capacity`：

Array的`reserveCapacity(_:)`：