I’m sorry that I long ago coined the term “objects” for this topic because it gets many people to focus on the lesser idea. The big idea is “messaging” – that is what the kernal[sic] of Smalltalk is all about… The key in making great and growable systems is much more to design how its modules communicate rather than what their internal properties and behaviors should be.

– by Alan Kay

在C语言调用一个方法其实就是跳到内存中的某一点并开始执行一段代码。没有任何动态的特性，因为这在编译时就决定好了。而在 Objective-C中，[object foo]语句并不会立即执行foo这个方法的代码。它是在运行时给object发送一条叫foo的消息。这个消息，也许会由object来处理，也许会被转发给另一个对象，或者不予理睬假装没收到这个消息。多条不同的消息也可以对应同一个方法实现。这些都是在程序运行的时候决定的。

事实上，在编译时Objective-C函数调用的语法都会被翻译成一个C的函数调用 - objc_msgSend().
比如，编译器会把

1

[target doMethodWith:var1];

编译成

1

objc_msgSend(target,@selector(doMethodWith:),var1);

显然，发送消息并不是直接的函数调用，到objc_msgSend里面就是Objective-C Runtime来处理了。

objc_object, objc_class 以及 Ojbc_method

在Objective-C中，本质上，类、对象和方法都是一个C的结构体

比如我们知道id就是指向一个Objective-C的对象的指针，也就是objc_object的实例，其中有一个isa指针，这个isa指向它所属的类。来看看它的定义

1
2
3

typedef struct objc_object {
    Class isa;
} *id;

所以当你拿到一个id指针之后，就可以获取这个对象的类，并且可以检测其是否响应一个selector。isa指向的objc_class实例的里面其实保存的就是该对象对应的类的信息。定义如下

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

typedef struct objc_class *Class;
struct objc_class {
    Class isa;
    Class super_class;
    const char *name;
    long instance_size;
    struct objc_ivar_list *ivars;
    struct objc_method_list **methodLists;
    struct objc_cache *cache;
    struct objc_protocol_list *protocols;
};

struct objc_method_list {
    struct objc_method_list *obsolete;
    int method_count;
    struct objc_method method_list[1];
};

我们看到这些类的信息包括，继承关系，实现的协议，方法列表，和属性列表，实例大小，ivar的类型和布局等等。其中方法都对应结构体是objc_method，这个结构体其实就是一个key/value对，定义如下

1
2
3
4
5
6
7

typedef struct objc_selector  *SEL;
typedef id (*IMP)(id self,SEL _cmd,...);
struct objc_method {
    SEL method_name;
    char *method_types;
    IMP method_imp;
};

key是所谓的Selector(相当于编译器生成的唯一的标识函数的字符串)；而值就是IMP，一个IMP就是一个函数指针，由编译器生成的，当你发起一个消息之后，最终它会执行的那个代码，就是由这个函数指针指定的。

从这些定义中可以看出， 发送一条消息，也就是objc_msgSend，大概到底做了什么事情。

举objc_msgSend(obj, foo)这个例子来说：

• 首先，通过 obj 的 isa 指针找到它的 class
• 在 class 的 method list 找 foo
• 如果 class 中没到 foo，继续往它的 superclass 中找
• 一旦找到 foo 这个函数，就去执行它的实现IMP

block的设计也类似，它也包含了isa的指针

1
2
3
4
5

struct Block_literal_1 {
    void *isa; // initialized to &_NSConcreteStackBlock or &_NSConcreteGlobalBlock
  ...
};

所以block像object一样也是可以响应消息的。

MetaClass

isa指向对象就是该object对应的类。也就是Objective-C的类本身也是一个对象，暂时我们称之为类对象(class object)。 它包含的信息包括，继承关系，实现的协议，方法列表，和属性列表，实例大小，ivar的类型和布局等等。当你进行类方法(class method)的调用的时候的时候，比方说

1

[NSObject alloc];

你事实上是把这个消息发给了这个类对象(class object)。

既然class object是一个实例，那么它必然是属于某一个类，这个类被称作metaclass。一个metaclass就是class object的描述，就像一个class是它的object的描述一样。

值得一提的是，metaclass的方法列表就是我们称之为class methods的东西：class本身应该响应的那些selectors。当你发送一个消息给class，也就是metaclass的实例的时候，objc_msgSend()会查找metaclass的方法列表（包括它的父类），来决定是否可以响应。一个class method记录在metaclass里，就像instance method记录在class中。

metaclass也是一个实例，也有父类，也有isa和super_class。最终的源头是一个特殊的root class。不过metaclass的isa指针其实是无关紧要的，因为现实中，没有人会给metaclass object发送消息的。
相对更重要的是metaclass的继承关系，metaclass有着和class一样的平行的继承关系。所以class methods也就相应的有了继承关系。
此外，由于root metaclass的父类是root class，所以每一个class object可以响应root class的instance methods
最后任何一个class object都是root class（或者它的子类的）实例

下面这张图能很好的总结上面的结论，始终要记住的是，当一个message发送给一个object的时候，这个object首先根据isa指针来寻找是否可以响应，然后在根据super_class指针在继承链中寻找

为啥我们要继承 Apple Classes

初学Cocoa开发的时候，多数教程都要我们继承一个类比方NSObject，然后我们就开始Coding了。比方说：

1

MyObject *object = [[MyObject alloc] init];

这个语句用来初始化一个实例，类似于 C++ 的 new 关键字。这个语句首先会执行MyObject这个类的+alloc方法，所以继承 Apple 的类我们不仅是获得了很多很好用的属性，而且也继承了这种内存分配的方法。

什么是Class Cache(objc_cache *cache)

每次发送一个消息的时候，都要去查找方法列表的实现有个问题，效率低。比如一个class往往只有20%的函数会被经常调用，可能占总调用次数的80%。每个消息都需要遍历一次objc_method_list并不合理。如果把经常被调用的函数缓存下来，那可以大大提高函数查询的效率。这也就是objc_class中另一个重要成员objc_cache做的事情 - 再找到foo之后，把foo的method_name作为key，method_imp作为value给存起来。当再次收到foo消息的时候，可以直接在cache里找到，避免去遍历objc_method_list.

说回 objc_msgSend 这个方法

1

[self printMessageWithString:@"Hello World!"];

会被编译器翻译成

1

objc_msgSend(self,@selector(printMessageWithString:),@"Hello World!");

objc_msgSend执行的步骤大致是这样：

• 检测这个selector是不是要忽略的。比如Mac OS X开发，有了垃圾回收就不理会retain,release这些消息了
• 检测这个target是不是nil。ObjC的特性是允许对一个nil对象执行任何一个方法不会Crash，因为会被忽略掉
• 如果上面两个都过了，那就开始查找这个类的IMP，先从cache里面找，找得到的话，就跳到对应的函数去执行
• 如果cache找不到就到成员方法列表里去找，还找不到，就到父类里去找
• 最后还找不到的话，就要进行消息转发逻辑

消息转发机制

在上面的例子中，如果@selector(printMessageWithString:)最终没有找到，通常情况下，程序会在运行时挂掉并抛出unrecognized selector sent to …的异常。但在异常抛出前，Objective-C的运行时会给你三次拯救程序的机会：

• Method resolution
• Fast forwarding
• Normal forwarding

Method Resolution

在找不到消息对应的函数后，首先，Objective-C运行时会调用+resolveInstanceMethod: 或者+resolveClassMethod:，让你有机会提供一个函数实现。如果你添加了函数并返回YES，那运行时系统就会重新启动一次消息发送的过程。以foo为例，你可以这么实现

1
2
3
4
5
6
7
8
9
10
11
12
13

void fooMethod(id obj, SEL _cmd)
{
    NSLog(@"Doing foo");
}

+ (BOOL)resolveInstanceMethod:(SEL)aSEL
{
    if(aSEL == @selector(foo:)){
        class_addMethod([self class], aSEL, (IMP)fooMethod, "v@:");
        return YES;
    }
    return [super resolveInstanceMethod];
}

Core Data有用到这个方法。NSManagedObjects中properties的getter和setter就是在运行时动态添加的

如果resolve方法返回NO，运行时就会移到下一步：消息转发（Message Forwarding）

PS：iOS 4.3 加入很多新的 runtime 方法，主要都是以 imp 为前缀的方法，比如 imp_implementationWithBlock() 用 block 快速创建一个 imp 。 上面的例子可以重写成：

1
2
3
4
5

IMP fooIMP = imp_implementationWithBlock(^(id _self) {
    NSLog(@"Doing foo");
});

class_addMethod([self class], aSEL, fooIMP, "v@:");

Fast forwarding

消息转发（Message Forwarding）首先会执行Fast forwarding，也就是如果目标对象实现了-forwardingTargetForSelector:，Runtime这时就会调用这个方法，给你把这个消息转发给其他对象的机会

1
2
3
4
5
6
7

- (id)forwardingTargetForSelector:(SEL)aSelector
{
    if(aSelector == @selector(foo:)){
        return alternateObject;
    }
    return [super forwardingTargetForSelector:aSelector];
}

只要这个方法返回的不是nil和self，整个消息发送的过程就会被重启，当然发送的对象会变成你返回的那个对象。否则，就会继续Normal Fowarding。

这里叫Fast，只是为了区别下一步的转发机制。因为这一步不会创建任何新的对象，但下一步转发会创建一个 NSInvocation 对象，所以相对更快点。

Normal forwarding

这一步是Runtime最后一次给你挽救的机会。首先它会发送-methodSignatureForSelector:消息获得函数的参数和返回值类型。如果-methodSignatureForSelector:返回nil，Runtime则会发出-doesNotRecognizeSelector:消息，程序这时也就挂掉了。如果返回了一个函数签名，Runtime就会创建一个NSInvocation对象并发送-forwardInvocation:消息给目标对象。

NSInvocation 实际上就是对一个消息的描述，包括selector 以及参数等信息。所以你可以在-forwardInvocation:里修改传进来的NSInvocation对象，然后发送-invokeWithTarget:消息给它，传进去一个新的目标：

1
2
3
4
5
6
7
8
9
10
11

- (void)forwardInvocation:(NSInvocation *)invocation
{
    SEL sel = invocation.selector;

    if([alternateObject respondsToSelector:sel]) {
        [invocation invokeWithTarget:alternateObject];
    }
    else {
        [self doesNotRecognizeSelector:sel];
    }
}

Cocoa 里很多地方都利用到了消息传递机制来对语言进行扩展，如 Proxies、NSUndoManager 跟 Responder Chain。NSProxy 就是专门用来作为代理转发消息的；NSUndoManager 截取一个消息之后再发送；而 Responder Chain 保证一个消息转发给合适的响应者。

Apple 设计这种机制的原因之一就是——用来模拟多重继承（ObjC 原生是不支持多重继承的）。或者把复杂设计隐藏起来。

参考资料

Understanding the Objective-C Runtime

Objective-C Runtime

Classes and metaclasses

初识第一面

HelloJNI.java

1
2
3
4
5
6
7
8
9
10
11
12
13
14

public class HelloJNI {
   static {
      System.loadLibrary("hello"); // Load native library at runtime
                                   // hello.dll (Windows) or libhello.so (Unixes)
   }

   // Declare a native method sayHello() that receives nothing and returns void
   private native void sayHello();

   // Test Driver
   public static void main(String[] args) {
      new HelloJNI().sayHello();  // invoke the native method
   }
}

HelloJNI.h/.c

1
2
3
4

JNIEXPORT void JNICALL Java_HelloJNI_sayHello(JNIEnv *env, jobject thisObj) {
   printf("Hello World!\n");
   return;
}

需要注意的有：

• 函数命名约定 Java_{package_and_classname}_{function_name}(JNI arguments)
• JNIEnv*: 对于JNI环境的引用, 通过这个入口可以进行jni函数
• jobject: 对于this对象的引用

JNI基础

JNI在native系统中定义了下面这些JNI数据类型，来对应Java的类型。

• Java基本类型：jint，jbyte，jshort，jlong，jfloat，jdouble，jchar，jboolean对应Java的int，byte，short，long，float，double，char，boolean
• Java应用类型：jobject对应java.lang.Object。同时还有一下子类型
• jclass -> java.lang.Class
• jstring -> java.lang.String
• jthrowable -> java.lang.Throwable
• jarray -> Java Array。也就是jintArray, jbyteArray, jshortArray, jlongArray, jfloatArray, jdoubleArray, jcharArray, jbooleanArray, jobjectArray.

由于native的函数都是接受JNI类型参数，返回JNI类型参数，所以一般情况下我们需要这样做：

• 把JNI的参数转换或者拷贝成C可以操作的类型，如jintArray到int[]
• 使用C类型参数完成计算
• 把结果转换或者拷贝成JNI类型并返回

JNI环境提供了大量的这些转换工作的工具可以帮助大家完成

在Java和Nativie之间传递参数

基础类型

1
2
3
4
5
6
7
8
9
10
11
12

    // In "win\jni_mh.h" - machine header which is machine dependent
  typedef long            jint;
  typedef __int64         jlong;
  typedef signed char     jbyte;

  // In "jni.h"
  typedef unsigned char   jboolean;
  typedef unsigned short  jchar;
  typedef short           jshort;
  typedef float           jfloat;
  typedef double          jdouble;
  typedef jint            jsize;

String

JNI环境提供了函数可以进行很方便的转换

• jstring -> char* : const char* GetStringUTFChars(JNIEnv*, jstring, jboolean*).
• char* -> jstring : jstring NewStringUTF(JNIEnv*, char*).

例如：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

JNIEXPORT jstring JNICALL Java_TestJNIString_sayHello(JNIEnv *env, jobject thisObj, jstring inJNIStr) {
   // Step 1: Convert the JNI String (jstring) into C-String (char*)
   const char *inCStr = (*env)->GetStringUTFChars(env, inJNIStr, NULL);
   if (NULL == inCSt) return NULL;

   // Step 2: Perform its intended operations
   printf("In C, the received string is: %s\n", inCStr);
   (*env)->ReleaseStringUTFChars(env, inJNIStr, inCStr);  // release resources

   // Prompt user for a C-string
   char outCStr[128];
   printf("Enter a String: ");
   scanf("%s", outCStr);    // not more than 127 characters

   // Step 3: Convert the C-string (char*) into JNI String (jstring) and return
   return (*env)->NewStringUTF(env, outCStr);
}

primitive数组

• jintArray -> jint[], jint* GetIntArrayElements(JNIEnv *env, jintArray a, jboolean *iscopy).
• jint[] -> jintArray, 首先分配内存jintArray NewIntArray(JNIEnv *env, jsize len), 然后填充void SetIntArrayRegion(JNIEnv *env, jintArray a, jsize start, jsize len, const jint *buf)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

JNIEXPORT jdoubleArray JNICALL Java_TestJNIPrimitiveArray_sumAndAverage
          (JNIEnv *env, jobject thisObj, jintArray inJNIArray) {
   // Step 1: Convert the incoming JNI jintarray to C's jint[]
   jint *inCArray = (*env)->GetIntArrayElements(env, inJNIArray, NULL);
   if (NULL == inCArray) return NULL;
   jsize length = (*env)->GetArrayLength(env, inJNIArray);

   // Step 2: Perform its intended operations
   jint sum = 0;
   int i;
   for (i = 0; i < length; i++) {
      sum += inCArray[i];
   }
   jdouble average = (jdouble)sum / length;
   (*env)->ReleaseIntArrayElements(env, inJNIArray, inCArray, 0); // release resources

   jdouble outCArray[] = {sum, average};

   // Step 3: Convert the C's Native jdouble[] to JNI jdoublearray, and return
   jdoubleArray outJNIArray = (*env)->NewDoubleArray(env, 2);  // allocate
   if (NULL == outJNIArray) return NULL;
   (*env)->SetDoubleArrayRegion(env, outJNIArray, 0 , 2, outCArray);  // copy
   return outJNIArray;
}

访问对象变量并且调用Java方法

访问实例对象

• GetObjectID
• GetFieldID
• GetInt
• SetFieldID

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40

JNIEXPORT void JNICALL Java_TestJNIInstanceVariable_modifyInstanceVariable
          (JNIEnv *env, jobject thisObj) {
   // Get a reference to this object's class
   jclass thisClass = (*env)->GetObjectClass(env, thisObj);

   // int
   // Get the Field ID of the instance variables "number"
   jfieldID fidNumber = (*env)->GetFieldID(env, thisClass, "number", "I");
   if (NULL == fidNumber) return;

   // Get the int given the Field ID
   jint number = (*env)->GetIntField(env, thisObj, fidNumber);
   printf("In C, the int is %d\n", number);

   // Change the variable
   number = 99;
   (*env)->SetIntField(env, thisObj, fidNumber, number);

   // Get the Field ID of the instance variables "message"
   jfieldID fidMessage = (*env)->GetFieldID(env, thisClass, "message", "Ljava/lang/String;");
   if (NULL == fidMessage) return;

   // String
   // Get the object given the Field ID
   jstring message = (*env)->GetObjectField(env, thisObj, fidMessage);

   // Create a C-string with the JNI String
   const char *cStr = (*env)->GetStringUTFChars(env, message, NULL);
   if (NULL == cStr) return;

   printf("In C, the string is %s\n", cStr);
   (*env)->ReleaseStringUTFChars(env, message, cStr);

   // Create a new C-string and assign to the JNI string
   message = (*env)->NewStringUTF(env, "Hello from C");
   if (NULL == message) return;

   // modify the instance variables
   (*env)->SetObjectField(env, thisObj, fidMessage, message);
}

访问静态变量

• GetStaticFieldID
• GetStaticField
• SetStaticField

1
2
3
4
5
6
7
8
9
10
11
12
13

JNIEXPORT void JNICALL Java_TestJNIStaticVariable_modifyStaticVariable
          (JNIEnv *env, jobject thisObj) {
   // Get a reference to this object's class
   jclass cls = (*env)->GetObjectClass(env, thisObj);

   // Read the int static variable and modify its value
   jfieldID fidNumber = (*env)->GetStaticFieldID(env, cls, "number", "D");
   if (NULL == fidNumber) return;
   jdouble number = (*env)->GetStaticDoubleField(env, cls, fidNumber);
   printf("In C, the double is %f\n", number);
   number = 77.88;
   (*env)->SetStaticDoubleField(env, cls, fidNumber, number);
}

访问方法和静态方法

• GetMethodID
• CallMethod
• GetStaticMethodID
• CallStaticMethod

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35

JNIEXPORT void JNICALL Java_TestJNICallBackMethod_nativeMethod
          (JNIEnv *env, jobject thisObj) {

   // Get a class reference for this object
   jclass thisClass = (*env)->GetObjectClass(env, thisObj);

   // Get the Method ID for method "callback", which takes no arg and return void
   jmethodID midCallBack = (*env)->GetMethodID(env, thisClass, "callback", "()V");
   if (NULL == midCallBack) return;
   printf("In C, call back Java's callback()\n");
   // Call back the method (which returns void), baed on the Method ID
   (*env)->CallVoidMethod(env, thisObj, midCallBack);

   jmethodID midCallBackStr = (*env)->GetMethodID(env, thisClass,
                               "callback", "(Ljava/lang/String;)V");
   if (NULL == midCallBackStr) return;
   printf("In C, call back Java's called(String)\n");
   jstring message = (*env)->NewStringUTF(env, "Hello from C");
   (*env)->CallVoidMethod(env, thisObj, midCallBackStr, message);

   jmethodID midCallBackAverage = (*env)->GetMethodID(env, thisClass,
                                  "callbackAverage", "(II)D");
   if (NULL == midCallBackAverage) return;
   jdouble average = (*env)->CallDoubleMethod(env, thisObj, midCallBackAverage, 2, 3);
   printf("In C, the average is %f\n", average);

   jmethodID midCallBackStatic = (*env)->GetStaticMethodID(env, thisClass,
                                 "callbackStatic", "()Ljava/lang/String;");
   if (NULL == midCallBackStatic) return;
   jstring resultJNIStr = (*env)->CallStaticObjectMethod(env, thisClass, midCallBackStatic);
   const char *resultCStr = (*env)->GetStringUTFChars(env, resultJNIStr, NULL);
   if (NULL == resultCStr) return;
   printf("In C, the returned string is %s\n", resultCStr);
   (*env)->ReleaseStringUTFChars(env, resultJNIStr, resultCStr);
}

创建java对象和对象数组

创建java对象

• FindClass
• NewObject
• AllocObject

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

JNIEXPORT jobject JNICALL Java_TestJNIConstructor_getIntegerObject
          (JNIEnv *env, jobject thisObj, jint number) {
   // Get a class reference for java.lang.Integer
   jclass cls = (*env)->FindClass(env, "java/lang/Integer");

   // Get the Method ID of the constructor which takes an int
   jmethodID midInit = (*env)->GetMethodID(env, cls, "<init>", "(I)V");
   if (NULL == midInit) return NULL;
   // Call back constructor to allocate a new instance, with an int argument
   jobject newObj = (*env)->NewObject(env, cls, midInit, number);

   // Try runnning the toString() on this newly create object
   jmethodID midToString = (*env)->GetMethodID(env, cls, "toString", "()Ljava/lang/String;");
   if (NULL == midToString) return NULL;
   jstring resultStr = (*env)->CallObjectMethod(env, newObj, midToString);
   const char *resultCStr = (*env)->GetStringUTFChars(env, resultStr, NULL);
   printf("In C: the number is %s\n", resultCStr);

   return newObj;
}

创建java数组

• NewObjectArray
• GetObjectArrayElement
• setObjectArrayElement

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39

JNIEXPORT jobjectArray JNICALL Java_TestJNIObjectArray_sumAndAverage
          (JNIEnv *env, jobject thisObj, jobjectArray inJNIArray) {
   // Get a class reference for java.lang.Integer
   jclass classInteger = (*env)->FindClass(env, "java/lang/Integer");
   // Use Integer.intValue() to retrieve the int
   jmethodID midIntValue = (*env)->GetMethodID(env, classInteger, "intValue", "()I");
   if (NULL == midIntValue) return NULL;

   // Get the value of each Integer object in the array
   jsize length = (*env)->GetArrayLength(env, inJNIArray);
   jint sum = 0;
   int i;
   for (i = 0; i < length; i++) {
      jobject objInteger = (*env)->GetObjectArrayElement(env, inJNIArray, i);
      if (NULL == objInteger) return NULL;
      jint value = (*env)->CallIntMethod(env, objInteger, midIntValue);
      sum += value;
   }
   double average = (double)sum / length;
   printf("In C, the sum is %d\n", sum);
   printf("In C, the average is %f\n", average);

   // Get a class reference for java.lang.Double
   jclass classDouble = (*env)->FindClass(env, "java/lang/Double");

   // Allocate a jobjectArray of 2 java.lang.Double
   jobjectArray outJNIArray = (*env)->NewObjectArray(env, 2, classDouble, NULL);

   // Construct 2 Double objects by calling the constructor
   jmethodID midDoubleInit = (*env)->GetMethodID(env, classDouble, "<init>", "(D)V");
   if (NULL == midDoubleInit) return NULL;
   jobject objSum = (*env)->NewObject(env, classDouble, midDoubleInit, (double)sum);
   jobject objAve = (*env)->NewObject(env, classDouble, midDoubleInit, average);
   // Set to the jobjectArray
   (*env)->SetObjectArrayElement(env, outJNIArray, 0, objSum);
   (*env)->SetObjectArrayElement(env, outJNIArray, 1, objAve);

   return outJNIArray;
}

本地和全局变量

任何类似FindClass(), GetMethodID(), GetFieldID()返回的引用是一个本地引用。

想要使用全局引用的话，需要使用NewGlobalRef()，DeleteGlobalRef()

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40

// Global Reference to the Java class "java.lang.Integer"
static jclass classInteger;
static jmethodID midIntegerInit;

jobject getInteger(JNIEnv *env, jobject thisObj, jint number) {

   // Get a class reference for java.lang.Integer if missing
   if (NULL == classInteger) {
      printf("Find java.lang.Integer\n");
    jclass classIntegerLocal = (*env)->FindClass(env, "java/lang/Integer");
      // Create a global reference from the local reference
      classInteger = (*env)->NewGlobalRef(env, classIntegerLocal);
      // No longer need the local reference, free it!
      //(*env)->DeleteLocalRef(env, classIntegerLocal);
   }

   if (NULL == classInteger) return NULL;

   // Get the Method ID of the Integer's constructor if missing
   if (NULL == midIntegerInit) {
      printf("Get Method ID for java.lang.Integer's constructor\n");
      midIntegerInit = (*env)->GetMethodID(env, classInteger, "<init>", "(I)V");
   }
   if (NULL == midIntegerInit) return NULL;

   // Call back constructor to allocate a new instance, with an int argument
   jobject newObj = (*env)->NewObject(env, classInteger, midIntegerInit, number);
   printf("In C, constructed java.lang.Integer with number %d\n", number);
   return newObj;
}

JNIEXPORT jobject JNICALL Java_TestJNIReference_getIntegerObject
          (JNIEnv *env, jobject thisObj, jint number) {
   return getInteger(env, thisObj, number);
}

JNIEXPORT jobject JNICALL Java_TestJNIReference_anotherGetIntegerObject
          (JNIEnv *env, jobject thisObj, jint number) {
   return getInteger(env, thisObj, number);
}

这里并不是单纯的翻译，只是试图总结一下fresco的特点

fresco是facebook开源的管理图片的库，主要还是为了管理里图片使用的内存

不同的内存区域

对于Android来说，可以使用的内存区域包括:

• java heap
• native heap
• ashmem

ashmem非常像native heap，但是有趣的是，它可以pin/unpin。所谓的unpin其实就是lazy free。也就是说，仅仅当Android需要更多内存的时候，才会释放这块内存。当Android重新pin这块内存时，如果这块内存不曾被是放过的话，那么原来的数据还在那里。

Purgeable bitmaps

ashmem并不能被java应用直接访问，除了一些特殊情况，恰好，图片就是其中的一个。当你创建一个解码过的图片，bitmap，api允许你指定这个图片是purgeable.

1
2
3

BitmapFactory.Options = new BitmapFactory.Options();
options.inPurgeable = true;
Bitmap bitmap = BitmapFactory.decodeByteArray(jpeg, 0, jpeg.length, options);

Purgeable的bitmap就在ashmem里。然而，garbage collector并不自动回收这些内存。Android系统只是在渲染系统渲染的时候pin住这些内存，然后在渲染结束后unpin他们。如果这些unpined图片需要再次被渲染的话，Android就会重新取得需要的内容，如果有必要的话，会重新在线(on the fly)解码。

但是在线解码(on the fly decode)发生在主线程里，由于这个原因，Google并不建议使用这个特性。目前的建议是使用inBitmap。但是这个新标志只有在android3.0里才存在。此外在4.4之前，这个特性还有个限制，是要求新解压的图片和原来的图片的大小要一致。这个要求显然并不适合大多数场景。

鱼和熊掌可以兼得

我们发现了一个既可以不用频繁释放／分配内存，又可以不阻塞UI的办法。也就是说，如果我们事先在非UI线程pin好一块内存，然后只要永远不要unpin它，这样我们就在ashmem上得到了一块内存，但是却不会引起UI阻塞的问题。非常幸运，我们NDK中有一个函数就是干这个的，AdnroidBitmap_lockPixels。这个函数设计之初是用来和unlockPixels配合使用来unpin这块内存的。当我们故意调用lockPixels但是并不调用unlockPixels时候，我们就很安全的在Java Heap之外得到了一块并不阻塞UI线程的内存。

像C++一样思考

ashmem没有类似garbage collector来保证不会内存泄漏。所以我们需要自己来保证。

在C++里，通常的解决办法是使用smart pointer类来实现引用计数。但这使用了cpp语言的工具，copy constructor，assignment constructor，deterministic destructor。这些语法糖在java中并不存在。所以我们自己要实现类似的机制。

我们通过两个类来实现这个机制。一个叫做SharedReference。这个类有两个方法，一个是addReference，一个是deleteReferece。通过这个来实现引用计数。

当然这个对于java程序员来说，明显很容易出错。java语言设计的时候就是要避免这样做。所以在SharedReference顶上，我们设计了CloseableReference。它是现实了Closeable接口，并且也实现了cloneabel。在构造函数和clone()里我们调用addReferece()。在close()里，我们调用deleteReference()。所以java开发者只需要遵循两个原则：

• 给一个CloseableReference赋值时候，调.clone()。
• 离开作用域时，调用.close()，通常是在一个final块里。

它不仅仅是一个loader，更是一个pipeline

在移动设备上显示一张图片要涉及很多步骤，如果我们把这些步骤看作是pipeline而不是loader，那么事情会完全不一样。每一步都应该尽可能的独立于其他步骤，每一步获得一些参数的输入，而产出一些结果。一些可能需要可以并行，一些需要串行。有一些仅仅需要在一些特定条件下执行，有一些对执行他们的线程有特定要求。而且考虑到弱网络和大图片，我们希望用户可以尽可能快的看到图片，即使是图片并没有完全下载下来。

对于Java来说，一般异步代码同步的时候我们会用到Future。但Future只能在执行完毕的时候带回来一个结果。当我们处理大图片的时候，我们需要处理一系列的结果。

我们的解决办法是涉及一个泛化版的Future，DataSource。它提供一个订阅的方法，调用者必须传递一个DataSubscriber和Executor给它。DataSubscriber将会收到DataSource发来的中间结果或者是最终结果的通知，并且会提供一个简单的办法去区分这两者。

在底层，上图里的每一个盒子都是使用一个新的架构实现的，叫做Producer/Consumer。这个架构是学习ReactiveX架构而搭建的。整个接口非常简洁，Producer只有一个方法，produceResults，它只有一个参数是Consumer对象。相对应的，Consumer只有一个方法叫做onNewResult。

我们使用一个向下面这样的一个系统来使producters变成一个链条。假设我们有一个producer，它的工作就是把类型I变成类型O。看起来如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

public class OutputProducer<I, O> implements Producer<O> {

  private final Producer<I> mInputProducer;

  public OutputProducer(Producer<I> inputProducer) {
    this.mInputProducer = inputProducer;
  }

  public void produceResults(Consumer<O> outputConsumer, ProducerContext context) {
    Consumer<I> inputConsumer = new InputConsumer(outputConsumer);
    mInputProducer.produceResults(inputConsumer, context);
  }

  private static class InputConsumer implements Consumer<I> {
    private final Consumer<O> mOutputConsumer;

    public InputConsumer(Consumer<O> outputConsumer) {
      mOutputConsumer = outputConsumer;
    }

    public void onNewResult(I newResult, boolean isLast) {
      O output = doActualWork(newResult);
      mOutputConsumer.onNewResult(output, isLast);
    }
  }
}

这个设计使得我们可以组建一个非常复杂的工作步骤链条，但是却能保证每一步逻辑上的独立性。

动画－－从一到多

表情一般来说是GIF或者WebP格式的，这带来了挑战，一个动画由许多bitmap组成，每一个都需要解码，存储和显示。对于大的动画来说，在内存中存储每一帧显然是不可能的。

所以我们设计了AnimatedDrawable，实现了Android的Animatable接口，可以支持以上两种格式，并且我们做了优化，如果比较小，我们可以把所有帧放在内存中，否则我们在线解码。不过这些都是高度可定制的

关于Drawee

我们以前的实现使用了View，当图片下载好之后把一个placeholder的View和交换，但是这样效率不高，因为换View会引起Android重新计算整个layout pass。所以一个更合理的做法是使用Android的Drawable，它可以实时交换而不引起任何其他代价。

所以我们引入了Drawee。这个MVC类似的架构用来显示图片。Modal叫做DraweeHierarchy，它由有层次的Drawable组成，每一个实现特定的功能，imaging，layering，fade-in，scaling等。

DraweeControllers连接image pipeline和处理image后台的操作。它从pipeline收到通知，然后决定怎么处理结果。它决定了DrawHierarchy实际显示了什么，不论是placeholder，错误，或者准备好的图片。

DraweeViews仅仅有非常有限的功能，但是它提供的功能却是决定性的。它接受Android系统的事件来发出信号说，这个view是不是还在屏幕上显示。当不在屏幕上的时候，DraweeView可以让DraweeController释放被图片使用资源。同时如果这个图片还没有下载的话，它可以取消，这样就可以节约网络带宽的使用。

完

翻译自inthechessefactory

什么是Android Gradle Build Tools

在把每个module的build.gradle文件传递给Gradle之前，Android Gradle Build Tools 用来提前处理下这些文件。

Gradle Build Tools的版本是在project的build.gradle里指定的，类似：

dependencies {
    classpath 'com.android.tools.build:gradle:1.2.3'
}

Gradle Build Tools版本和Gradle版本对应关系如下：

The new Android Gradle Build Tools

使用新的Gradle Build Tools的话，只需要换掉build tools的version

dependencies {
    classpath 'com.android.tools.build:gradle-experimental:0.1.0'
}

不过只有gradle2.5才能匹配使用，所以需要设置gradle-wrapper.properties

distributionUrl=https\://services.gradle.org/distributions/gradle-2.5-bin.zip

然后像下面这样编辑模块的build.gradle

apply plugin: 'com.android.model.application'

model {
    android {
        compileSdkVersion = 22
        buildToolsVersion = "23.0.0 rc3"

        defaultConfig.with {
            applicationId = "com.inthecheesefactory.hellojni25"
            minSdkVersion.apiLevel = 15
            targetSdkVersion.apiLevel = 22
            versionCode = 1
            versionName = "1.0"
        }
    }

    android.buildTypes {
        release {
            isMinifyEnabled = false
            proguardFiles += file('proguard-rules.pro')
        }
    }
}

dependencies {
    compile fileTree(dir: 'libs', include: ['*.jar'])
    compile 'com.android.support:appcompat-v7:22.2.0'
}

仔细看就会发现，plugin不再是com.android.application，而是com.android.model.application。
+=被引入表示在一个collection中增加一些元素。

支持 NDK

修改项目的local.properites文件

ndk.dir=PATH_TO_NDK_ROOT

，或者直接使用android studio下载ndk

然后在java的package里创建HelloJni.java文件

1
2
3

public class HelloJni {
    public native String stringFromJNI();
}

在src/main目录下创建jni文件夹，然后创建hello-jni.c文件

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41

#include <string.h>
#include <jni.h>

jstring
Java_com_inthecheesefactory_hellojni25_HelloJni_stringFromJNI( JNIEnv* env,
                                                  jobject thiz )
{
#if defined(__arm__)
  #if defined(__ARM_ARCH_7A__)
    #if defined(__ARM_NEON__)
      #if defined(__ARM_PCS_VFP)
        #define ABI "armeabi-v7a/NEON (hard-float)"
      #else
        #define ABI "armeabi-v7a/NEON"
      #endif
    #else
      #if defined(__ARM_PCS_VFP)
        #define ABI "armeabi-v7a (hard-float)"
      #else
        #define ABI "armeabi-v7a"
      #endif
    #endif
  #else
   #define ABI "armeabi"
  #endif
#elif defined(__i386__)
   #define ABI "x86"
#elif defined(__x86_64__)
   #define ABI "x86_64"
#elif defined(__mips64)  /* mips64el-* toolchain defines __mips__ too */
   #define ABI "mips64"
#elif defined(__mips__)
   #define ABI "mips"
#elif defined(__aarch64__)
   #define ABI "arm64-v8a"
#else
   #define ABI "unknown"
#endif

    return (*env)->NewStringUTF(env, "Hello from JNI !!  Compiled with ABI " ABI ".");
}

请记住让com_inthecheesefactory_hellojni25和HelloJni.java的包名是一致的。makefile不再需要了。

现在在MainActivity.java里测试一下

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

public class MainActivity extends AppCompatActivity {
  @Override
  protected void onCreate(Bundle savedInstanceState) {
      super.onCreate(savedInstanceState);
      setContentView(R.layout.activity_main);

      Toast.makeText(MainActivity.this,
                    new HelloJni().stringFromJNI(),
                    Toast.LENGTH_LONG).show();
  }
    ...

    static {
        System.loadLibrary("hello-jni");
    }
}

more video

那么当我们如何编译framework时使它可以支持所有architecture呢

参考资料1

参考资料2

要点如下：

在build phases里增加一个脚本

######################
# Options
######################

REVEAL_ARCHIVE_IN_FINDER=false

FRAMEWORK_NAME="${PROJECT_NAME}"

SIMULATOR_LIBRARY_PATH="${BUILD_DIR}/${CONFIGURATION}-iphonesimulator/${FRAMEWORK_NAME}.framework"

DEVICE_LIBRARY_PATH="${BUILD_DIR}/${CONFIGURATION}-iphoneos/${FRAMEWORK_NAME}.framework"

UNIVERSAL_LIBRARY_DIR="${BUILD_DIR}/${CONFIGURATION}-iphoneuniversal"

FRAMEWORK="${UNIVERSAL_LIBRARY_DIR}/${FRAMEWORK_NAME}.framework"


######################
# Build Frameworks
######################

xcodebuild -workspace ${PROJECT_NAME}.xcworkspace -scheme ${PROJECT_NAME} -sdk iphonesimulator -configuration ${CONFIGURATION} clean build CONFIGURATION_BUILD_DIR=${BUILD_DIR}/${CONFIGURATION}-iphonesimulator 2>&1

xcodebuild -workspace ${PROJECT_NAME}.xcworkspace -scheme ${PROJECT_NAME} -sdk iphoneos -configuration ${CONFIGURATION} clean build CONFIGURATION_BUILD_DIR=${BUILD_DIR}/${CONFIGURATION}-iphoneos 2>&1

######################
# Create directory for universal
######################

rm -rf "${UNIVERSAL_LIBRARY_DIR}"

mkdir "${UNIVERSAL_LIBRARY_DIR}"

mkdir "${FRAMEWORK}"


######################
# Copy files Framework
######################

cp -r "${DEVICE_LIBRARY_PATH}/." "${FRAMEWORK}"


######################
# Make an universal binary
######################

lipo "${SIMULATOR_LIBRARY_PATH}/${FRAMEWORK_NAME}" "${DEVICE_LIBRARY_PATH}/${FRAMEWORK_NAME}" -create -output "${FRAMEWORK}/${FRAMEWORK_NAME}" | echo

# For Swift framework, Swiftmodule needs to be copied in the universal framework
if [ -d "${SIMULATOR_LIBRARY_PATH}/Modules/${FRAMEWORK_NAME}.swiftmodule/" ]; then
    cp -f ${SIMULATOR_LIBRARY_PATH}/Modules/${FRAMEWORK_NAME}.swiftmodule/* "${FRAMEWORK}/Modules/${FRAMEWORK_NAME}.swiftmodule/" | echo
fi

if [ -d "${DEVICE_LIBRARY_PATH}/Modules/${FRAMEWORK_NAME}.swiftmodule/" ]; then
    cp -f ${DEVICE_LIBRARY_PATH}/Modules/${FRAMEWORK_NAME}.swiftmodule/* "${FRAMEWORK}/Modules/${FRAMEWORK_NAME}.swiftmodule/" | echo
fi

######################
# On Release, copy the result to release directory
######################

OUTPUT_DIR="${PROJECT_DIR}/Output/${FRAMEWORK_NAME}-${CONFIGURATION}-iphoneuniversal/"

rm -rf "$OUTPUT_DIR"
mkdir -p "$OUTPUT_DIR"

cp -r "${FRAMEWORK}" "$OUTPUT_DIR"

if [ ${REVEAL_ARCHIVE_IN_FINDER} = true ]; then
    open "${OUTPUT_DIR}/"
fi

layout: post title: “到底能不能在extension里override一个函数？” date: 2015-07-22 11:12:03 +0800 comments: true

categories: iOS Swift

Swift教程中明确说了，extension并不能override一个已有的函数！可是最近发现有人extension UIImageView时，可以override layoutSubviews()，到底什么鬼？？

在stackoverflow上找到了答案，并且自己也确认过了。

解释是这样的：

至少在目前版本（swift1.1， 1.2），只要在如下两种情况下就可以override函数

• 涉及到的类都是从NSObject继承来的,不使用inout修饰符并且没有enum
• 或者使用了@objc修饰符的函数

核心思想是，只有Objective-C compatible的方法和属性才能在extension里override

请参考下面的例子

例子1

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

class A : NSObject { }
class B : A { }

class SubNSObject : NSObject {}
class NotSubbed {}
enum SomeEnum { case c1, c2; }

extension A
{
    var y : String { get { return "YinA"; } }
    func f() -> A { return A(); }
    func g(val: SubNSObject, test: Bool = false) { }

    func h(val: NotSubbed, test: Bool = false) { }
    func j(val: SomeEnum) { }
    func k(val: SubNSObject, inout test: Bool) { }
}

extension B
{
    // THESE OVERIDES DO COMPILE:
    override var  y : String { get { return "YinB"; } }
    override func f() -> A { return A(); }
    override func g(val: SubNSObject, test: Bool) { }

    // THESE OVERIDES DO NOT COMPILE:
    //override func h(val: NotSubbed, test: Bool = false) { }
    //override func j(val: SomeEnum) { }
    //override func k(val: SubNSObject, inout test: Bool) { }
}

例子2

1
2
3
4
5
6
7
8
9
10
11
12
13

class A { }

class B : A { }

extension A
{
    @objc var y : String { get { return "YinA" } }
}

extension B
{
   @objc override var y : String { get { return "YinB" } }
}

创建Constraint

你可以使用NSLayoutConstraint来表示constrains。

如果要创建constraints，一般要使用 constraintsWithVisualFormat:options:metrics:views:。

第一个参数是一个visual format string，这种visual format language已经尽可能的是自我解释的。一个view使用一个方括号来代表，view之间的连接用横杠来代表。visual format language的语法参见Visual Format Language

比如说，

上图可以表示为:

[button1]-12-[button2]

如果是标准的Aqua距离的话，可以不用标注数字

[button1]-[button2]

view的名字来自于参数views字典。key就是这里用到名字，而value是对应的view对象。

可以使用NSDictionaryOfVariableBindings来创建该字典，该函数使用view对象的名字来作为key值

NSDictionary *viewsDictionary =
    NSDictionaryOfVariableBindings(self.button1, self.button2);

NSArray *constraints =
    [NSLayoutConstraint constraintsWithVisualFormat:@"[button1]-[button2]"
                        options:0 metrics:nil views:viewsDictionary];

并不是每一种constraint都可以通过visual format language来表示的。比如有一种常用的constraint不能用该语言来表达，比如固定宽高比，这时候需要用这样的函数：

constraintWithItem:attribute:relatedBy:toItem:attribute:multiplier:constraint:

比如上面contraint还可以这样创建

[NSLayoutConstraint constraintWithItem:self.button1 
                             attribute:NSLayoutAttributeRight
                             relatedBy:NSLayoutRelationEqual 
                                toItem:self.button2
                             attribute:NSLayoutAttributeLeft 
                            multiplier:1.0 
                              constant:-12.0];

Installing Constraints

我们必须把constraint加到view中，这个view应该是所有涉及到的view的祖先view，通常是最近的那个祖先view。

关于这个我们可以使用NSView的addConstraint:

相关的函数还有：

• removeConstraint:
• constraints
• fittingSize

参考资料

• 最重要的一个开源库可以帮助我们不用写那么多无聊的代码

Masonry

[view1 mas_makeConstraints:^(MASConstraintMaker *make) {
    make.edges.equalTo(superview).with.insets(padding);
}];

• 从此爱上iOS Autolayout
• Beginning Auto Layout Tutorial in iOS 7: Part 1
• Beginning Auto Layout Tutorial in iOS 7: Part 2

当你设计一个container的时候，你需要显式的在你的container，和它的子controller之间创建父子关系。如下图。注意，不仅仅controller之间需要显式的指定关系，view之间的关系也需要显式的指定。

常见的Container设计的例子

Navigation Controller管理着一些由子View Controller组成的栈

如图所示，Navigation Controller管理着一系列不同的子ViewController。在这个栈最上面的ViewController的View会被显示出来。

Navigation Controller定义了一些行为

• topViewController – 目前显示的vc
• viewControllers – 所有子vc
• pushViewController:animated: – 显示
• popViewControllerAnimated: – 弹出
• delegate – 可以让使用者当状态改变的时候收到通知

Navigation Controller 使用子VC的一些属性来改变当前显示的内容。

• navigationItem – 提供了navigation toolbar的内容
• toolbarItem – 提供了底部bar的内容
• editButtonItem – 提供了可以从navigation item访问子view的途径，这样就可以改变子view的edit mode

Tab Bar Controller使用一个子VC的集合

Tab Bar Controller定义了一些行为：

• viewControllers – 所有子vc
• selectedViewController – 设置或读取哪个子vc
• delegate – 可以让使用者当状态改变的时候收到通知

Tab Bar Controller 使用子VC的一些属性来改变当前显示的内容。

• tabBarItem – 提供了底部bar的内容

Page Controller使用DataSource去显示新的子VC

Page Controller支持无限多的页面显示，所以把所有的page都放在内存中是不可能的。相反，page controller在需要的时候拉取需要的page。这样page controller就使用一个pull model而不是让app把所有的page一下子push到里面

Page Controller定义了一些行为：

• spineLocation – 定义page是如何组织的，有时候只显示一个page，有时候需要两个
• transitionStyle – 定义了过场动画的风格

实现自定义Container Controller

增加和移除子vc

始终应该记住的是，在addSubview之前addChildViewController,在removeFromSuperVieww之后removeFromParentViewController。

另外，设置子view的大小最好也在addSubview之前

增加

- (void) displayContentController: (UIViewController*) content;
{
    [self addChildViewController:content];                 
    content.view.frame = [self frameForContentController]; 
    [self.view addSubview:self.currentClientView];
    [content didMoveToParentViewController:self];          
}

• addChildViewController会自动调用willMoveToPa

移除

- (void) hideContentController: (UIViewController*) content
{
    [content willMoveToParentViewController:nil];  
    [content.view removeFromSuperview];            
    [content removeFromParentViewController];      
}

简单的转场动画

- (void) cycleFromViewController: (UIViewController*) oldC
        toViewController: (UIViewController*) newC
{
    [oldC willMoveToParentViewController:nil];                        
    [self addChildViewController:newC];

    newC.view.frame = [self newViewStartFrame];                       
    CGRect endFrame = [self oldViewEndFrame];

    [self transitionFromViewController: oldC toViewController: newC   
          duration: 0.25 options:0
          animations:^{
             newC.view.frame = oldC.view.frame;                       
             oldC.view.frame = endFrame;
          }
          completion:^(BOOL finished) {
             [oldC removeFromParentViewController];                   
             [newC didMoveToParentViewController:self];
          }];
}

自定义显示和旋转的Callback行为

多数时候不用管这个事情，但是有时候你希望自己控制消息发送的时机之类的情况

- (BOOL) shouldAutomaticallyForwardAppearanceMethods
{
    return NO;
}

-(void) viewWillAppear:(BOOL)animated
{
    [self.child beginAppearanceTransition: YES animated: animated];
}

-(void) viewDidAppear:(BOOL)animated
{
    [self.child endAppearanceTransition];
}

-(void) viewWillDisappear:(BOOL)animated
{
    [self.child beginAppearanceTransition: NO animated: animated];
}

-(void) viewDidDisappear:(BOOL)animated
{
    [self.child endAppearanceTransition];
}

旋转与显示类似，首先要重载shouldAutomaticallyForwardRotationMethods，然后在合适的地方调用

• willRotateToInterfaceOrientation:duration:
• willAnimateRotationToInterfaceOrientation:duration:
• didRotateFromInterfaceOrientation:

Best practices

• 不要干这事！！因为毕竟实现一个复杂的container不是一件容易的事情
• 只访问子VC的最顶层的那个View，其他View不要碰！
• 如果需要子VC暴露一些接口，可以使用protocol！

如下

@protocol MyContentContainerProtocol <NSObject>
    ...
@end
- (void) displayContentController: (UIViewController<MyContentContainerProtocol>*) content;

注意：当且仅当你允许不同的App的clients需要跨进程来访问你的service，并且需要在service里处理多线程问题的时候，你才应该使用AIDL。如果仅仅是App内部的client来访问服务，并且不需要IPC的话，只要使用Binder就好了。如果是需要IPC，但是不用处理并发的话，那么只要用Messager就好了。只有既要IPC，又要处理并发，才需要用AIDL。总之，只有在必须的时候才使用AIDL

关于AIDL调用的背后

另一个需要知道的是，AIDL的接口调用是直接调用，所以并不能对调用接口的线程有任何假设。调用的线程在本地进程执行还是在远程进程执行的结果可能是非常不同的。其中：

• 如果是本地进程进行AIDL调用，服务端代码是在进行调用的这个线程中执行的
• 如果是远程进程进行AIDL调用，你就必须为服务端代码同时在不同线程中执行做好准备，也就是说，这些代码必须是线程安全的
• oneway关键字用来修饰远调用，使用后表示这个远程调用并不阻塞，它仅仅是发送了数据就立刻返回。而该关键字并不影响本地调用

创建AIDL过程

• 创建.aidl文件

使用Android Studio自己创建IRemoteService.aidl就很好，比如定义接口getPid()

interface IRemoteService {
    int getPid();
}

• 实现该接口的service

例如实现文件AIDLService.java，这个service在onBind函数中返回的binder里含有IRemoteService.aidl定义的接口的实现

public class AIDLService extends Service {

    private final IRemoteService.Stub binder = new IRemoteService.Stub(){

        @Override
        public int getPid() throws RemoteException {
            return android.os.Process.myPid();
        }
    };

    @Override
    public IBinder onBind(Intent intent) {
        return binder;
    }
}

• 使用该AIDL

像使用普通service一样

IRemoteService remoteService;

ServiceConnection remoteServiceConnection = new ServiceConnection() {
    @Override
    public void onServiceConnected(ComponentName componentName, IBinder iBinder) {
        remoteService = IRemoteService.Stub.asInterface(iBinder);
    }

    @Override
    public void onServiceDisconnected(ComponentName componentName) {
        remoteService = null;
    }
};

Intent intent = new Intent(MainActivity.this, AIDLService.class);
bindService(intent, remoteServiceConnection, BIND_AUTO_CREATE);
startService(intent);

int remotePid = remoteService.getPid();

在AIDL中传递对象

比如我们希望AIDL接口可以传递名为Student的对象,需要做以下一些事情

• 定义Student.aidl

其中声明Student类型

parcelable Student;

• 定义aidl接口（IRemoteAPI.aidl）

注意要import相应的Student类

import com.morgenworks.alchemistli.remotelibrary.Student;

interface IRemoteAPI {
    Student getName();
    void setName(in Student st);
}

• 定义实现了Parcelble接口的Student类

实现Parcelble接口需要实现这样几个函数, Student(Parcel source), writeToParcel(…), readescribeContents(), 以及static Creator CREATOR

public class Student implements Parcelable {
    public String name;
    public String fatherName;

    @Override
    public int describeContents() {
        return 0;
    }

    @Override
    public void writeToParcel(Parcel dest, int flags) {
        dest.writeString(name);
        dest.writeString(fatherName);
    }

    public Student(Parcel source){
        name = source.readString();
        fatherName = source.readString();
    }

    public Student(){}

    public void setName(String name){
        this.name = name;
    }

    public void setFatherName(String fatherName){
        this.fatherName = fatherName;
    }

    public static final Creator<Student> CREATOR = new Creator<Student>() {
        @Override
        public Student createFromParcel(Parcel source) {
            return new Student(source);
        }

        @Override
        public Student[] newArray(int size) {
            return new Student[size];
        }
    };
}

• 实现AIDL接口的服务

就像实现普通的AIDL接口服务一样

public class RemoteAPIService extends Service {
    private Student stuInfo;

    private IRemoteAPI.Stub binder = new IRemoteAPI.Stub() {
        @Override
        public Student getName() throws RemoteException {
            stuInfo.name = stuInfo.name.toUpperCase();
            return stuInfo;
        }

        @Override
        public void setName(Student st) throws RemoteException {
            stuInfo = st;
        }
    };

    @Override
    public IBinder onBind(Intent intent) {
        return binder;
    }
}

instance method是属于实例的函数，type mothod则是属于type的函数

Local and External Parameter Names for Method

local and external parameter name的默认行为并不等同于function

swift的method的参数名字非常像objective－c。比如说，一般来说，swift的method的名字带有by， with， for等介词，例如incrementBy。

需要指出的是，swift默认会给第一个参数local parameter name，但是对于第二个以后参数则默认生成local and external parameter name。 class Counter { var count : Int = 0 func incrementBy(amount: Int, numberOfTimes: Int){ count += amount * numberOfTimes } } swift会把amount看作local name，但是会把numberOfTimes看作local and external name。所以调用该method，需要像如下这样 let counter = Counter() counter.incrementBy(5, numberOfTimes: 3) 当然也可以显式的提供第一个参数的external name或者不提供非第一参数的external name class Counter2{ var count : Int = 0 func incrementBy(#amount: Int, _ numberOfTimes: Int){ count += amount * numberOfTimes } } let count2 = Count2() count2.incrementBy(amount: 5, 3)

Self Propety

一般情况下可以不写，但是如果有歧义就需要写 struct Point{ var x = 0.0, y = 0.0 func isToTheRightOfX(x: Double) -> Bool{ return self.x > x // must use self } func description() -> String{ return “x: (x), y: (y)”) //no need to use self } }

在instance method内改变值类型变量自身

对于value types来说，一般情况下，instance method不能更改属性，但是加上mutating关键字来改变这点。 struct Point{ var x = 0.0, y = 0.0 mutating func moveByX(deltaX: Double, y deltaY: Double){ x += deltaX y += deltaY } }

Assigning to self Within a Mutating Method

struct Point{
    var x = 0.0, y = 0.0
    mutating func moveByX(deltaX: Double, y deltaY: Double){
        self ＝ Point(x: x+deltaX, y: y + deltaY)
    }
}

enum TriStateSwitch {
    case Off, Low, High
    mutating func next() {
        switch self {
        case Off:
            self = Low
        case Low:
            self = High
        case High:
            self = Off
        }
    }
}

Type Method

type method在类中使用关键字class来表示，在结构体和枚举中使用static来表示

在type method中，self表示类型本身，而不是实例本身

​struct​ ​LevelTracker​ {
​    ​static​ ​var​ ​highestUnlockedLevel​ = ​1
​    ​static​ ​func​ ​unlockLevel​(​level​: ​Int​) {
​        ​if​ ​level​ > ​highestUnlockedLevel​ { ​highestUnlockedLevel​ = ​level​ }
​    }
​    ​static​ ​func​ ​levelIsUnlocked​(​level​: ​Int​) -> ​Bool​ {
​        ​return​ ​level​ <= ​highestUnlockedLevel
​    }
​    ​var​ ​currentLevel​ = ​1
​    ​mutating​ ​func​ ​advanceToLevel​(​level​: ​Int​) -> ​Bool​ {
​        ​if​ ​LevelTracker​.​levelIsUnlocked​(​level​) {
​            ​currentLevel​ = ​level
​            ​return​ ​true
​        } ​else​ {
​            ​return​ ​false
​        }
​    }
​}

以下是一些sample code, 先构造一些类

class Person{ var residence: Residence? }

class Residence {
    var rooms = [Room]()
    var numberOfRooms: Int { return rooms.count }

    subscript(i: Int) -> Room {
        get { return rooms[i] }
        set { rooms[i] = newValue }
    }

    func printNumberOfRooms(){
        println("The number of rooms is \(numberOfRooms)")
    }
}

class Room {
    let name: String
    init(name: String){ self.name = name }
}

class Address {
    var buildingName: String?
    var buildingNumber: String?
    var street: String?

    func buildingIdentifier() -> String? {
        if buildingName != nil {
            return buildingName
        } else if buildNumber != nil {
            return buldingNumber
        } else {
            return nil
        }
    }
}

下面就是如何使用optional chain

let john = Person()
if let roomCount = john.residence?.numberOfRooms {
    println("john's residence has \(roomCount) rooms.")
}
// will print nothing

let someAddress = Address()
someAddress.buildingNumber = "29"
someAddress.street = "Acacia Road"
john.residence?.address = someAddress //will fail

Residence里的方法printNumberOfRooms()没有返回值，但是这意味着该方法返回类型是Void，也就是返回值是(),也就是一个空的tuple. 在optional chain里，会返回Void?

if john.residence?.printNumberOfRoom() != nil {
    println("It was possible to print the number of rooms."
} 
// will print nothing

对于通过optional chain来设置属性也一样

if (john.residence?.address = someAddress) != nil {
    println("It was possible to set the address."
}
// will print nothing

通过optional chaining访问subscript

if let firstRoomName = john.residence?[0].name {
    println("the first room name is \(firstRoomName)")
}
// will print nothing

let johnsHouse = Residence()
johnsHouse.rooms.append(Room(name: "Living Room"))
johnsHouse.rooms.append(Room(name: "Kitchen"))
john.residence = johnsHouse

if let firstRoomName = john.residence?[0].name {
    println("the first room name is \(firstRoomName)")
}
// prints "the first room name is Living Room"

访问optional的subscript

var testScrores = ["Dave": [86, 82, 84], "Bev": [79, 94, 81]]
testScores["Dave"]?[0] = 91
testScores["Bev"]?[0]++
testScores["Brain"]?[0]

多层的optional chain， 原则是 * 如果试图查询的东西的类型并非是optional的，会由于使用了chain而变成optional * 如果正在查询的东西已经是optional的，它不会因为chain变得“更”optional（optional的optional)

下面是代码示例

if let johnsStreet = john.residence?.address?.street{
    println("John's street name is \(johnsStreet)")
}
// print nothing

let johnsAddress = Address()
johnsAddress.buildingName = "The Larches"
johnsAddress.street = "Laurel Street"
john.residence?.address = johnsAddress

if let johnsStreet = john.residence?.address?.street{
    println("John's street name is \(johnsStreet)")
}
// print "John's street name is Laurel Street"

if let beginsWithThe = john.residence?.address?.buildingIdentifier()?.hasPrefix("The") {
    if beginWithThe {
        println("John's building identifier begins with \"The\".")
    }
}

extensions可以

• 增加computed property和computed static property
• 定义instance methods和type methods
• 提供新的initializers
• 定义subscripts
• 定义和使用新的nested types
• 为一个type实现一个protocol

extension不可以

• extension可以增加新的funtionality，但是不能覆盖以有的functionality
• extension不能增加stored properties，或者给存在的property增加property observers
• extension不能增加新的designated initializer

Extension 语法

extension SomeType {
    ...
}

extiosion SomeType: Someprotocol, AnotherProtocol {
    ...
}

一个有趣的例子

extension Double {
    var km: Double { return self * 1000.0 }
    var m: Double { return self }
}

let aMarathon = 42.m + 195.m
println("A marathon is \(aMarathon) masters long")

Initializers

struct Size { var width = 0.0, height = 0.0 }
struct Point { var x = 0.0, y = 0.0 }
struct Rect {
    var origin = Point()
    var size = Size()
}

extension Rect{
    init(center: Point, size: Size){
        let originX = center.x - (size.width / 2)
        let originY = center.y - (size.height / 2)
        self.init(origin: Point(x:originX, y:originY), size: size)
    }
}

Methods

extension Int{
    func repetitions(task: ()-> ()){
        for i in 0..<self {
            task()
        }
    }
}

3.repetitions{ println("hello") }

Mutating Instance Methods

extension Int {
    mutating func square(){
        self = self * self
    }
}

var someInt = 3.square()

Subscripts

extension Int {
    subscript(var digitIndex: Int) -> Int{
        var decimalBase = 1
        while digitIndex > 0 {
            decimalBase *= 10
            --digitIndex
        }

        return (self / decimalBase) % 10
    }
}

74631295[1] //return 9

Nested Tyeps

extension Int {
    enum Kind {
        case Negative, Zero, Positive
    }

    var kind: Kind {
        switch self {
        case 0: retrun .Zero
        case let x where x > 0: return .Positive
        default: return .Negative
        }
    }
}

关于optional，剩下的只是swift里面有关的特殊术语，搞清楚还是很有必要的

Force Unwrapping

Force Unwarpping指的是把optional对象转化成一个非空的对象

Optional Binding

其基本形式是

if let constantName = someOptional

while let constantName = someOptional

Implicity Unwrapped Optionals

一个optinal变量可以定义为implicity unwrapped optionals, 那么使用这个变量的时候就不再需要force unwrap, 一旦unwrap失败，程序会崩溃

var storyboardName : String! = "hello"

一个类继承的例子

class MediaItem{
}

class Movie: MediaItem{
    var director : String
    init(director: String){ self.director = director; super.init() }

}

class Song: MediaItem{
    var artist : String
    init(artist: String){ self.artist = artist; super.init() }
}

类型检查使用is

let library = [Movie("d1"), Song("a1"), Song("a2"), Movie("d2")]

var movieCount = 0
var songCount = 0

for item in library {
    if item as Movie {
        ++movieCount
    } else if item is Song {
        ++songCount
    }
}

值得一提的是，is不仅仅用来检测有继承关系的类，而且可以用来检测是否实现了某个接口

protocal HasArea{
    var area: Double { get }
}

class Circle: HasArea{
    var radius: Double
    var area: Double { return 3.14 * radius * radius }
    init(radius: Double){ self.radius = radius }
}

var circle = Circle(2.5)
if circle is HasArea {
    println("Area: \(circle.area)")
}

类型转换

可以使用as来进行类型转换

可以用两种方式来使用as, as?和as!

as?表示不确定该转换是否能成功，as!表示一定会成功，但是如果运行时转换失败的话，程序会崩掉

for item in library {
    if let movie = item as? Movie {
        println("Director: \(movie.director)")
    } else if let song = item as? Song {
        println("Artist: \(song.artist)")
    }
}

Any和AnyObject的类型转换

其实，Any和AnyObject的转换和普通的类型转换是一样的。值得说的是为什么swift要有他们两个。

• AnyObject可以代表任何class类型的实例
• Any却可以代表任何类型的实例，包括funtion类型

举两个例子，第一个例子

let someObjects: [AnyObject] = [Movie('d1'),Movie('d1'),Movie('d1')]
for object in someObjects{
    let movie = object as! Movie
    println("Movie director: \(movie.director)")
}

该例子中，还可以直接cast整个数组

for movie in someObjects as! [Movie] {
    println("Movie director: \(movie.director)")
}

另外一个是关于Any的例子

var things = [Any]()

things.append(0)
things.append(0.0)
things.append(42)
things.append(3.14)
things.append("hello")
things.append((3.0, 5.0))
things.append(Movie("d1"))
things.append({(name: String) -> String in 
    "Hello, \(name)" })

for thing in things{
    switch thing{
        case 0 as Int: 
            println("zero as an Int")
        case 0 as Double:
            println("zero as an Double")
        case let someInt as Int:
            println("an integer value of \(someInt)")
        case let someDouble as Double where someDouble > 0:
            println("a positive double : \(someDouble)")
        case is Double:
            println("some other double value <= 0")
        case let someString as String:
            println("a string value : \(someString)")
        case let (x, y) as (Double, Double) :
            println("an (x,y) point at \(x), \(y)")
        case let movie as Movie:
            println("a movie director: \(movie.director)")
        case let stringConverter as String -> String:
            println(stringConverter("Michael")
        default:
            println("something else")
    }
}

需要指出，在switch的case语句中，使用的as是强制转换版的，并不写作as?或者as!，在case语句中使用这种检查总是安全的。

这里不是要权威的解释initilization，而是想总结一些swift initilizer的特点

初始化发生在class, structure, enumeration初始准备的过程中。coder可以通过定义initializers来实现初始化。值得注意的是，initializers没有返回值。

此外，class还可以实现一个’deinitializer’

如何定义initializer

定义initializer需要用关键字init

Simplest initializer

struct Fahrenhit{
    var temperature: Double
    init(){
        temperature = 32.0
    }
}

自定义initializer

可以使用initializer parameters来自定义initializer

struct Celsius{
    var temperatureInCelsius: Double
    init(fromFahrenhit fahrenhit: Double){
        temperatureInCelsius = (fahrenhit - 32.0)/1.8
    }
    init(fromKelvin kelvin: Double){
        temperatureInCelsius = kelvin - 273.15
    }
}

调用initializer

由于initializer每个参数默认有external name，所以调用的时候一定要写external name

let boilingPoint = Celsius(fromFahrenhit: 212.0)
let freezePoint = Celsius(fromKelvin: 273.15)

Default initializer

• 如果structure或者base class没有提供initializer的话，编译器会提供一个默认的init()。

• 对于structure来说如果没有任何自定义的initializer的话，编译器会还会提供一个memberwise initializer

Initializer Delegation

• value类型和class类型的initilizer delegation的规则是不同的

Structure和Enumunation的Intializer Delegation

• 只能在initializer中调用self.init

Class Inheriantance and Initialization

class的initializer分为Designated initializer和Convenience initializer

Designated initializer和Convenience initializer

Designated initializer是primary initializer，每个class只要要有一个

init(parameters) { statements }

Convenience initializer是为了方便而存在的，需要通过Designated initializer来初始化，关键字为convenience

convenience init(parameters){ statements }

Initializer Delegattion for Class Types

• Rule1 一个designated initializer必须调用它直接父类的designated initializer
• Rule2 一个convenience initializer必须调用它自己的另一个initializer
• Rule3 一个convenience initializer必须最终调用它自己的designated initializer

可以简单总结为

• designated initializer必须delegate up
• convenience initializer必须delegate across

可以看下图

下面是一个更复杂的例子

两阶段的初始化

在初始化过程中，首先所有的类属性都会被赋予初始值，当这一阶段完成之后，然后在被initializer里代码设置其值
关于这点，swift的编译器会进行一些检查

• safety check 1 : designated initializer在delegates up到superclass initializer之前，必须保证所有属性都被初始化了

• safety check 2 : designated initializer必须先delegate up到superclass initializer才能赋值给继承下来的属性

• safety check 3 : convenience initializer必须先delegate到其他initializer才能修改属性

• safety check 4 : initializer需要第一阶段初始化完成才能修改属性，调用成员方法

两阶段初始化的具体过程不详细说了，需要知道的是，当内存分配好之后，先由子类的initializer负责初始化自己的属性，然后向上传递控制权，父类做相同的事情，直到根基类。这时候第一阶段初始化就完成了。第二阶段初始化是从顶向下进行，这时候self就可以访问了，同时可以修改访问self的属性了，调用成员函数了。

第一阶段初始化

第二阶段初始化

Initializer的Inheritance和Override

原则上，swift不允许initializer继承，但是在下列情况下可以继承

• 如果子类没有写任何designated initializer，子类可以继承所有父类的designated initializer

• 如果子类提供了所有父类的designated initializer的实现－－无论是继承而来的，还是自己override的，那么自动继承所有的父类的convenience initializer

下面举个例子：

class Food{
    var name : String
    init(name: String){ self.name = name }
    convenience init() { self.init(name: "[Unnamed]") }
}

下图显示了initializer chain

class RecipeIngredient: Food{
    var quantity : Int
    init(name: String, quantity: Int){
        self.quantity = quantity
        super.init(name: name)
    }
    override convenience init(name: String){
        self.init(name: name, quantity: 1)
    }
}

initializer chain如图

class ShoppingListItem: RecipeIngredient {
    var purchased = false
    var description: String {
        var output = "\(quantity) x \(name)"
        output += purchased ? "OK" : "Not"
        return output
    }
}

initializer chain如图

Failable Initializer

语法如下

init?(parameters){ statments }

举个例子来说 struct Animal{ let species: String init?(species: String){ if species.isEmpty { return nil } self.species = species } }

通过return nil，我们可以表示初始化失败

可以像如下方式来使用 let someCreature = Animal(species: “”) if let griaffe = someCreature{ println(“no species”) }

Failable Initializer for Enumerations

enum TemperatureUnit{
    case Kelvin, Celsius, Fahrenheit
    init?(symbol: Character){
        switch symbol{
        case "K": self = .Kelvin
        case "C": self = .Celsius
        case "K": self = .Fahrenheit
        default:
            return nil
        }
    }
}


if let unknowUnit = TemperatureUnit("X") { println("no such unit") }

Automatic Failable Initializer for Enumerations with Raw Value

enum TemperatureUnit : Character{
    case Kelvin = "K", Celsius = "C", Fahrenheit = "F"
}

if let unknowUnit = TemperatureUnit("D"){ println ("no such unit") }

Failable Initializer for Classes & Propagation of Initialization Failure

对于类来说，初始化失败只能在所有属性都已经被设置了初始值之后发生

class Product{
    let name: String!
    init?(name: String){
        self.name = name
        if name.isEmpty { return nil }
    }
}

class CartItem: Product{
    let quantity: Int!
    init?(name: String, quantity: Int){
        self.quantity = quantity
        super.init(name: name)
        if(quantity < 1) { return nil }
    }
}

Override a Failable Initializer

你可以使用non-failable initializer去override父类的failable initializer，但这时就不能再delegate up到failable initilizer

class Document{
    var name: String?
    init() {}
    init?(name: String){
        self.name = name
        if name.isEmpty { return nil }
    }
}

class AutomaticallyNamedDocument: Document{
    override init(){ 
        super.init()
        self.name = "[Untitled]"
    }
    override init(name: String){
        super.init()
        if name.isEmpty{ 
            self.name = "[Untitled]"
        }
        else{ 
            self.name = name 
        }
    }
}

Required Initializer

required modifier表示该类的每一个子类都必须实现这个initilizer
在子类实现该initializer时候必须也添加required

class SomeClass{
    required init(){ ... }
}

class SomeSubClass{
    required init(){ ... }
}

Setting a Default Property Value with a Closure or Function

class SomeClass{
    let someProperty: SomeType = {
        return someValue
    }()
}

一个普通的Swift file

class SwiftFrameworks {
    init() { println("Class init") }
    func doSomething() { println("Yeah, it works") }
} 

为了让它可以在framework中工作，需要让所有类和方法都是public的

public class SwiftFrameworks { 
    public init() { println("Class init") } 
    public func doSomething() { println("Yeah, it works") } 
} 

建立framework工程

添加刚才的swift文件

编译

有时候编译时候并不能产生target，切换一下设备（可能是xcode的bug），然后找到build好的target所在文件夹

添加到测试工程中

把编译好的framework拖拽到测试工程中，之后在embed中添加该framework

然后

import SwiftFramework
let swiftFramework = SwiftFramework()
swiftFramework.helloWorld()

大功告成～

• use Heap tool and Allocation tracing
• start a empty activity
• jump to the activity in question
• trigger gc
• watch the heap

android studio can trace the general memory usage by Memory Moniter

watch the video here