package com.designpattern.adapter;
/**
 * 目标接口
 * @author atopom
 *
 */
public interface Duck {
	void quack();
	void fly();
}

package com.designpattern.adapter;
/**
 * 目标接口实现类
 * @author atopom
 *
 */
public class MallardDuck implements Duck {
	@Override
	public void quack() {
		System.out.println("Quack");
	}
	@Override
	public void fly() {
		System.out.println("I'm flying");
	}
}

/**
 * 被适配者Adaptee：Turkey
 * @author atopom
 *
 */
public interface Turkey {
	void gobble();
	void fly();
}

package com.designpattern.adapter;
/**
 * 被适配者实现类
 * @author atopom
 *
 */
public class WildTurkey implements Turkey {
	@Override
	public void gobble() {
		System.out.println("Gobble gobble");
	}
	@Override
	public void fly() {
		System.out.println("I'm flying a short distance");
	}
}

package com.designpattern.adapter;
/**
 * 适配器Adapter
 * @author atopom
 *
 */
public class TurkeyAdapter implements Duck {
	Turkey turkey;
	public TurkeyAdapter(Turkey turkey) {
		this.turkey = turkey;
	}
	@Override
	public void quack() {
		turkey.gobble();
	}
	@Override
	public void fly() {
		for(int i = 0; i < 5; i++) {
			turkey.fly();
		}
	}
}

package com.designpattern;
import com.designpattern.adapter.*;
/*
 * 适配器模式
 *
 * 将一个类的接口，转换成客户期望的另一个接口。
 * 适配器让原本接口不兼容的类可以合作无间。
 *
 * 适配器的工作量，和目标接口的大小成正比。
 *
 * 目的：
 * 在不改变原有设计的基础上（或者说，在无法改变原有设计的时候），
 * 为适应新的需求而做出的一个方案。
 */
/**
 * 适配器模式测试类
 * @author atopom
 *
 */
public class AdapterTestDrive {
	public static void main(String[] args) {
		MallardDuck duck = new MallardDuck();
		WildTurkey turkey = new WildTurkey();
		Duck turkeyAdapter = new TurkeyAdapter(turkey);
		System.out.println("The Turkey says...");
		turkey.gobble();
		turkey.fly();
		System.out.println("\nThe Duck says...");
		testDuck(duck);
		System.out.println("\nThe TurkeyAdapter says...");
		testDuck(turkeyAdapter);
	}
	static void testDuck(Duck duck) {
		duck.quack();
		duck.fly();
	}
}

The Turkey says...
Gobble gobble
I'm flying a short distance
The Duck says...
Quack
I'm flying
The TurkeyAdapter says...
Gobble gobble
I'm flying a short distance
I'm flying a short distance
I'm flying a short distance
I'm flying a short distance
I'm flying a short distance

public class Book implements Parcelable {
    private String name;
    private int price;
    public String getName() {
        return name;
    }
    public int getPrice() {
        return price;
    }
    public void setName(String name) {
        this.name = name;
    }
    public void setPrice(int price) {
        this.price = price;
    }
    public Book() {
    }
    protected Book(Parcel in) {
        name = in.readString();
        price = in.readInt();
    }
    // 固定写法，在Pacel进行反序列化的时候，会通过反射调用CREATOR的方法。    
    public static final Creator<Book> CREATOR = new Creator<Book>() {
        @Override
        public Book createFromParcel(Parcel in) {
            return new Book(in);
        }
        @Override
        public Book[] newArray(int size) {
            return new Book[size];
        }
    };
    @Override
    public int describeContents() {
        return 0;
    }
    @Override
    public void writeToParcel(Parcel dest, int flags) {
        dest.writeString(name);
        dest.writeInt(price);
    }
}

public final void writeParcelable(Parcelable p, int parcelableFlags) {
    //  先向流中写入p的ClassName
    writeParcelableCreator(p);
    // 然后直接调用p的writeToParcel，这个方法也就是我们自己重写的
    p.writeToParcel(this, parcelableFlags);
}

public final <T extends Parcelable> T readParcelable(ClassLoader loader) {
    // 1. 首先会调用到readParcelableCreator，通过反射读取我们类中定义的CREATOR
    Parcelable.Creator<?> creator = readParcelableCreator(loader);
    if (creator == null) {
        return null;
    }
    if (creator instanceof Parcelable.ClassLoaderCreator<?>) {
      Parcelable.ClassLoaderCreator<?> classLoaderCreator =
          (Parcelable.ClassLoaderCreator<?>) creator;
      return (T) classLoaderCreator.createFromParcel(this, loader);
    }
    // 2. 然后直接调用CREATOR.createFromParcel(parcel)
    return (T) creator.createFromParcel(this);
}

// 首先会调用到readParcelableCreator，通过反射读取我们类中定义的CREATOR
public final Parcelable.Creator<?> readParcelableCreator(ClassLoader loader) {
    // 首先把类名读取出来
    String name = readString();
    Parcelable.Creator<?> creator;
    // mCreators做了一下缓存，如果之前某个classloader把一个parcelable的Creator获取过
    // 那么就不需要通过反射去查找了
    synchronized (mCreators) {
        HashMap<String,Parcelable.Creator<?>> map = mCreators.get(loader);
        if (map == null) {
            map = new HashMap<>();
            mCreators.put(loader, map);
        }
        creator = map.get(name);
        if (creator == null) {
            try {
                // If loader == null, explicitly emulate Class.forName(String) "caller
                // classloader" behavior.
                ClassLoader parcelableClassLoader =
                        (loader == null ? getClass().getClassLoader() : loader);
                // 加载我们自己实现Parcelable接口的类
                Class<?> parcelableClass = Class.forName(name, false,
                        parcelableClassLoader);
                Field f = parcelableClass.getField("CREATOR");
                Class<?> creatorType = f.getType();
                creator = (Parcelable.Creator<?>) f.get(null);
            }
            catch (Exception e) {
                    // catch exception
            }
            if (creator == null) {
                throw new BadParcelableException("Parcelable protocol requires a "
                        + "non-null Parcelable.Creator object called "
                        + "CREATOR on class " + name);
            }
            map.put(name, creator);
        }
    }
    return creator;
}

/**
 * Person类除了writeReplace在序列化时用到,其他的黑科技方法都不会被调用
 * 原因是我们在writeReplace中将序列化对象替换成了内部代理类,所以以后的序列化过程就是针对SerializableProxy
 */
class Person implements Serializable {
	private static final long serialVersionUID = 1L;
	public String desc;
	public Person(String desc) {
		this.desc = desc;
	}
	static class SerializableProxy implements Serializable {
		private static final long serialVersionUID = 1L;
		private String desc;
		private SerializableProxy(Person s) {
			this.desc = s.desc;
		}
		/**
		 * 在这里恢复外围类 注意看这里!!!最大的好处就是我们最后得到的外围类是通过构造器构建的!
		 *
		 * @return
		 */
		private Object readResolve() {
			return new Person(desc);
		}
	}
	/**
	 * 外围类直接替换成静态内部代理类作为真正的序列化对象
	 *
	 * @return
	 */
	private Object writeReplace() {
		return new SerializableProxy(this);
	}
	/**
	 * 这里主要是为了防止攻击,任何以Persion声明的对象字节流都是流氓!!
	 * 因为我在writeReplace中已经把序列化的实例指向了SerializableProxy
	 *
	 * @param stream
	 * @throws InvalidObjectException
	 */
	private void readObject(ObjectInputStream stream) throws InvalidObjectException {
		throw new InvalidObjectException("proxy requied!");
	}
}

// Book.java
package com.gn100.ipcserver.aidl;
import android.os.Parcel;
import android.os.Parcelable;
public class Book implements Parcelable {
    private String name;
    private int price;
    public String getName() {
        return name;
    }
    public int getPrice() {
        return price;
    }
    public void setName(String name) {
        this.name = name;
    }
    public void setPrice(int price) {
        this.price = price;
    }
    public Book() {
    }
    protected Book(Parcel in) {
        name = in.readString();
        price = in.readInt();
    }
    public static final Creator<Book> CREATOR = new Creator<Book>() {
        @Override
        public Book createFromParcel(Parcel in) {
            return new Book(in);
        }
        @Override
        public Book[] newArray(int size) {
            return new Book[size];
        }
    };
    @Override
    public int describeContents() {
        return 0;
    }
    @Override
    public void writeToParcel(Parcel dest, int flags) {
        dest.writeString(name);
        dest.writeInt(price);
    }
    public void readFromParcel(Parcel dest) {
        name = dest.readString();
        price = dest.readInt();
    }
    @Override
    public String toString() {
        return "name : " + name + " , price : " + price;
    }
}

// Book.aidl
//第一类AIDL文件的例子
//这个文件的作用是引入了一个序列化对象 Book 供其他的AIDL文件使用
//注意：Book.aidl与Book.java的包名应当是一样的
package com.gn100.ipcserver.aidl;
//注意parcelable是小写
parcelable Book;

// BookManager.aidl
package com.gn100.ipcserver.aidl;
import com.gn100.ipcserver.aidl.Book;
import com.gn100.ipcserver.aidl.OnNewBookArrivedListener;
interface BookManager {
    // 所有的返回值前都不需要加任何东西
    List<Book> getBooks();
    Book getBook(String name);
    int getBookCount();
    // 传参时除了Java基本类型以及String，CharSequence之外的类型
    // 都需要在前面加上定向tag，具体加什么根据需求而定
    void addBookIn(in Book book);
    void addBookOut(out Book book);
    void addBookInout(inout Book book);
    void registerListener(OnNewBookArrivedListener listener);
    void unregisterListener(OnNewBookArrivedListener listener);
}

sourceSets {
    main {
        java.srcDirs = ['src/main/java', 'src/main/aidl']
    }
}

// AIDLService.java
package com.gn100.ipcserver.service;
import android.app.Service;
import android.content.Intent;
import android.os.IBinder;
import android.os.RemoteCallbackList;
import android.os.RemoteException;
import android.support.annotation.Nullable;
import android.text.TextUtils;
import android.util.Log;
import com.gn100.ipcserver.aidl.Book;
import com.gn100.ipcserver.aidl.BookManager;
import com.gn100.ipcserver.aidl.OnNewBookArrivedListener;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.CopyOnWriteArrayList;
import java.util.concurrent.atomic.AtomicBoolean;
public class AIDLService extends Service {
    private static final String TAG = AIDLService.class.getCanonicalName();
    private AtomicBoolean mIsServiceDestoryed = new AtomicBoolean(false);
    private List<Book> mBooks = new CopyOnWriteArrayList<>();
    private RemoteCallbackList<OnNewBookArrivedListener> mNewBookArrivedListeners = new RemoteCallbackList<OnNewBookArrivedListener>();
    private BookManager.Stub mBookManager = new BookManager.Stub() {
        @Override
        public List<Book> getBooks() throws RemoteException {
            synchronized (this) {
                Log.e(TAG, "invoking getBooks() method , now the list is : " + mBooks.toString());
                return mBooks != null ? mBooks : new ArrayList<Book>();
            }
        }
        @Override
        public Book getBook(String name) throws RemoteException {
            synchronized (this) {
                Book book = null;
                if (mBooks != null && !TextUtils.isEmpty(name)) {
                    for (Book b : mBooks) {
                        if (name.equals(b.getName())) {
                            book = b;
                        }
                    }
                }
                Log.e(TAG, "invoking getBook() method , now the book is : " + book.toString());
                return book;
            }
        }
        @Override
        public int getBookCount() throws RemoteException {
            synchronized (this) {
                Log.e(TAG, "invoking getBookCount() method , now the bookCount is : " + mBooks.size());
                return mBooks == null ? 0 : mBooks.size();
            }
        }
        @Override
        public void addBookIn(Book book) throws RemoteException {
            synchronized (this) {
                if (mBooks == null) {
                    mBooks = new ArrayList<>();
                }
                if (book == null) {
                    Log.e(TAG, "Book is null in In");
                    book = new Book();
                }
                //尝试修改book的参数，主要是为了观察其到客户端的反馈
                book.setPrice(11111);
                if (!mBooks.contains(book)) {
                    mBooks.add(book);
                }
                //打印mBooks列表，观察客户端传过来的值
                Log.e(TAG, "invoking addBookIn() method , now the list is : " + mBooks.toString());
            }
        }
        @Override
        public void addBookOut(Book book) throws RemoteException {
            synchronized (this) {
                if (mBooks == null) {
                    mBooks = new ArrayList<>();
                }
                if (book == null) {
                    Log.e(TAG, "Book is null in Out");
                    book = new Book();
                }
                //尝试修改book的参数，主要是为了观察其到客户端的反馈
                book.setPrice(22222);
                if (!mBooks.contains(book)) {
                    mBooks.add(book);
                }
                //打印mBooks列表，观察客户端传过来的值
                Log.e(TAG, "invoking addBookOut() method , now the list is : " + mBooks.toString());
            }
        }
        @Override
        public void addBookInout(Book book) throws RemoteException {
            synchronized (this) {
                if (mBooks == null) {
                    mBooks = new ArrayList<>();
                }
                if (book == null) {
                    Log.e(TAG, "Book is null in Inout");
                    book = new Book();
                }
                //尝试修改book的参数，主要是为了观察其到客户端的反馈
                book.setPrice(33333);
                if (!mBooks.contains(book)) {
                    mBooks.add(book);
                }
                //打印mBooks列表，观察客户端传过来的值
                Log.e(TAG, "invoking addBookInout() method , now the list is : " + mBooks.toString());
            }
        }
        @Override
        public void registerListener(OnNewBookArrivedListener listener) throws RemoteException {
            boolean success = mNewBookArrivedListeners.register(listener);
            if(success) {
                Log.d(TAG, "register success");
            } else {
                Log.e(TAG, "not found, can not register");
            }
        }
        @Override
        public void unregisterListener(OnNewBookArrivedListener listener) throws RemoteException {
            boolean success = mNewBookArrivedListeners.unregister(listener);
            if(success) {
                Log.d(TAG, "unregister success");
            } else {
                Log.e(TAG, "not found, can not unregister");
            }
        }
    };
    @Nullable
    @Override
    public IBinder onBind(Intent intent) {
        Log.d(TAG, "onBind");
        return mBookManager.asBinder();
    }
    @Override
    public boolean onUnbind(Intent intent) {
        Log.d(TAG, "onUnbind");
//        return super.onUnbind(intent);
        return true; // for invoke onRebind method
    }
    @Override
    public void onRebind(Intent intent) {
        Log.d(TAG, "onRebind");
        super.onRebind(intent);
    }
    @Override
    public void onCreate() {
        Log.d(TAG, "onCreate");
        super.onCreate();
        new Thread(new ServiceWorker()).start();
    }
    @Override
    public int onStartCommand(Intent intent, int flags, int startId) {
        Log.d(TAG, "onStartCommand");
        return super.onStartCommand(intent, flags, startId);
    }
    @Override
    public void onDestroy() {
        Log.d(TAG, "onDestroy");
        super.onDestroy();
        mIsServiceDestoryed.set(true);
    }
    private void onNewBookArrived(Book book) throws RemoteException {
        Log.d(TAG, "onNewBookArrived");
        mBooks.add(book);
        final int N = mNewBookArrivedListeners.beginBroadcast();
        for (int i = 0; i < N; i++) {
            OnNewBookArrivedListener l = mNewBookArrivedListeners.getBroadcastItem(i);
            if (l != null) {
                try {
                    l.onNewBookArrived(book);
                } catch (RemoteException e) {
                    e.printStackTrace();
                }
            }
        }
        mNewBookArrivedListeners.finishBroadcast();
    }
    private class ServiceWorker implements Runnable {
        @Override
        public void run() {
            // do background processing here.....
            while (!mIsServiceDestoryed.get()) {
                try {
                    Thread.sleep(5000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                int bookId = mBooks.size() + 1;
                Book newBook = new Book();
                newBook.setName("newBook#" + bookId);
                newBook.setPrice(100);
                try {
                    onNewBookArrived(newBook);
                } catch (RemoteException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

<service
    android:name=".service.AIDLService"
    android:exported="true">
        <intent-filter>
            <action android:name="com.gn100.aidl"/>
            <category android:name="android.intent.category.DEFAULT"/>
        </intent-filter>
</service>

// AIDLActivity.java
package com.gn100.ipcclient;
import android.content.ComponentName;
import android.content.Intent;
import android.content.ServiceConnection;
import android.os.Bundle;
import android.os.Handler;
import android.os.IBinder;
import android.os.Message;
import android.os.RemoteException;
import android.support.v7.app.AppCompatActivity;
import android.util.Log;
import android.view.View;
import com.gn100.ipcserver.aidl.Book;
import com.gn100.ipcserver.aidl.BookManager;
import com.gn100.ipcserver.aidl.OnNewBookArrivedListener;
import java.util.List;
public class AIDLActivity extends AppCompatActivity implements View.OnClickListener {
    private static final String TAG = AIDLActivity.class.getCanonicalName();
    private BookManager mBookManager;
    private static final int MESSAGE_NEW_BOOK_ARRIVED = 1;
    private Handler mHandler = new Handler() {
        @Override
        public void handleMessage(Message msg) {
            switch (msg.what) {
                case MESSAGE_NEW_BOOK_ARRIVED:
                    Log.d(TAG, "receive new book :" + msg.obj);
                    break;
                default:
                    super.handleMessage(msg);
            }
        }
    };
    private OnNewBookArrivedListener mOnNewBookArrivedListener = new OnNewBookArrivedListener.Stub() {
        @Override
        public void onNewBookArrived(Book newBook) throws RemoteException {
            mHandler.obtainMessage(MESSAGE_NEW_BOOK_ARRIVED, newBook)
                    .sendToTarget();
        }
    };
    private IBinder.DeathRecipient mDeathRecipient = new IBinder.DeathRecipient() {
        @Override
        public void binderDied() {
            Log.d(TAG, "binder died. tname:" + Thread.currentThread().getName());
            if (mBookManager == null)
                return;
            mBookManager.asBinder().unlinkToDeath(mDeathRecipient, 0);
            mBookManager = null;
            // TODO:这里重新绑定远程Service
        }
    };
    private ServiceConnection mServiceConnection = new ServiceConnection() {
        @Override
        public void onServiceConnected(ComponentName name, IBinder service) {
            Log.d(TAG, "onServiceConnected");
            mBookManager = BookManager.Stub.asInterface(service);
            try {
                Log.i(TAG, "register listener:" + mOnNewBookArrivedListener);
                mBookManager.registerListener(mOnNewBookArrivedListener);
                mBookManager.asBinder().linkToDeath(mDeathRecipient, 0);
            } catch (RemoteException e) {
                e.printStackTrace();
            }
        }
        @Override
        public void onServiceDisconnected(ComponentName name) {
            Log.d(TAG, "onServiceDisconnected. tname:" + Thread.currentThread().getName());
        }
    };
    @Override
    protected void onStart() {
        super.onStart();
    }
    @Override
    protected void onStop() {
        super.onStop();
    }
    @Override
    protected void onDestroy() {
        super.onDestroy();
        if (mBookManager != null
                && mBookManager.asBinder().isBinderAlive()) {
            try {
                Log.i(TAG, "unregister listener:" + mOnNewBookArrivedListener);
                mBookManager.unregisterListener(mOnNewBookArrivedListener);
                unbindService(mServiceConnection);
            } catch (RemoteException e) {
                e.printStackTrace();
            }
        }
    }
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_aidl_service);
        findViewById(R.id.btn_add_book_in).setOnClickListener(this);
        findViewById(R.id.btn_add_book_out).setOnClickListener(this);
        findViewById(R.id.btn_add_book_in_out).setOnClickListener(this);
        findViewById(R.id.btn_get_books).setOnClickListener(this);
        bindService();
    }
    @Override
    public void onClick(View v) {
        switch (v.getId()) {
            case R.id.btn_add_book_in:
                addBookIn();
                break;
            case R.id.btn_add_book_out:
                addBookOut();
                break;
            case R.id.btn_add_book_in_out:
                addBookInout();
                break;
            case R.id.btn_get_books:
                getBooks();
                break;
        }
    }
    private void addBookIn() {
        new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    Book book = new Book();
                    book.setName("Android築基篇");
                    book.setPrice(199);
                    Log.d(TAG, "book info addBookIn before : " + book);
                    mBookManager.addBookIn(book);
                    Log.d(TAG, "book info addBookIn after : " + book);
                } catch (RemoteException e) {
                    e.printStackTrace();
                }
            }
        }).start();
    }
    private void addBookOut() {
        new Thread(new Runnable() {
            @Override
            public void run() {
                Book book = new Book();
                book.setName("Android築基篇");
                book.setPrice(199);
                try {
                    Log.d(TAG, "book info addBookOut before : " + book);
                    mBookManager.addBookOut(book);
                    Log.d(TAG, "book info addBookOut after : " + book);
                } catch (RemoteException e) {
                    e.printStackTrace();
                }
            }
        });
    }
    private void addBookInout() {
        new Thread(new Runnable() {
            @Override
            public void run() {
                Book book = new Book();
                book.setName("Android築基篇");
                book.setPrice(199);
                try {
                    Log.d(TAG, "book info addBookInout before : " + book);
                    mBookManager.addBookInout(book);
                    Log.d(TAG, "book info addBookInout after : " + book);
                } catch (RemoteException e) {
                    e.printStackTrace();
                }
            }
        });
    }
    private void getBooks() {
        new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    List<Book> books = mBookManager.getBooks();
                    Log.d(TAG, "books info = " + books.toString());
                } catch (RemoteException e) {
                    e.printStackTrace();
                }
            }
        });
    }
    private void bindService() {
        Intent intent = new Intent();
        intent.setAction("com.gn100.aidl");
        intent.setPackage("com.gn100.ipcserver");
        bindService(intent, mServiceConnection, BIND_AUTO_CREATE);
    }
}

public Messenger(IBinder target) { mTarget = IMessenger.Stub.asInterface(target); }

cMessenger = msg.replyTo;
cMessenger.send(message);

public class MessengerService extends Service {  
    /** For showing and hiding our notification. */  
    NotificationManager mNM;  
    /** Keeps track of all current registered clients. */  
    ArrayList<Messenger> mClients = new ArrayList<Messenger>();  
    /** Holds last value set by a client. */  
    int mValue = 0;  
    /**
     * Command to the service to register a client, receiving callbacks
     * from the service.  The Message's replyTo field must be a Messenger of
     * the client where callbacks should be sent.
     */  
    static final int MSG_REGISTER_CLIENT = 1;  
    /**
     * Command to the service to unregister a client, ot stop receiving callbacks
     * from the service.  The Message's replyTo field must be a Messenger of
     * the client as previously given with MSG_REGISTER_CLIENT.
     */  
    static final int MSG_UNREGISTER_CLIENT = 2;  
    /**
     * Command to service to set a new value.  This can be sent to the
     * service to supply a new value, and will be sent by the service to
     * any registered clients with the new value.
     */  
    static final int MSG_SET_VALUE = 3;  
    /**
     * Handler of incoming messages from clients.
     */  
    class IncomingHandler extends Handler {  
        @Override  
        public void handleMessage(Message msg) {  
            switch (msg.what) {  
                case MSG_REGISTER_CLIENT:  
                    mClients.add(msg.replyTo);  
                    break;  
                case MSG_UNREGISTER_CLIENT:  
                    mClients.remove(msg.replyTo);  
                    break;  
                case MSG_SET_VALUE:  
                    mValue = msg.arg1;  
                    for (int i = mClients.size() - 1; i >= 0; i --) {  
                        try {  
                            mClients.get(i).send(Message.obtain(null,  
                                    MSG_SET_VALUE, mValue, 0));  
                        } catch (RemoteException e) {  
                            // The client is dead.  Remove it from the list;   
                            // we are going through the list from back to front   
                            // so this is safe to do inside the loop.   
                            mClients.remove(i);  
                        }  
                    }  
                    break;  
                default:  
                    super.handleMessage(msg);  
            }  
        }  
    }  
    /**
     * Target we publish for clients to send messages to IncomingHandler.
     */  
    final Messenger mMessenger = new Messenger(new IncomingHandler());  
    @Override  
    public void onCreate() {  
        mNM = (NotificationManager)getSystemService(NOTIFICATION_SERVICE);  
        // Display a notification about us starting.   
        showNotification();  
    }  
    @Override  
    public void onDestroy() {  
        // Cancel the persistent notification.   
        mNM.cancel(R.string.remote_service_started);  
        // Tell the user we stopped.   
        Toast.makeText(this, R.string.remote_service_stopped, Toast.LENGTH_SHORT).show();  
    }  
    /**
     * When binding to the service, we return an interface to our messenger
     * for sending messages to the service.
     */  
    @Override  
    public IBinder onBind(Intent intent) {  
        return mMessenger.getBinder();  
    }  
    /**
     * Show a notification while this service is running.
     */  
    private void showNotification() {  
        // In this sample, we'll use the same text for the ticker and the expanded notification   
        CharSequence text = getText(R.string.remote_service_started);  
        // Set the icon, scrolling text and timestamp   
        Notification notification = new Notification(R.drawable.stat_sample, text,  
                System.currentTimeMillis());  
        // The PendingIntent to launch our activity if the user selects this notification   
        PendingIntent contentIntent = PendingIntent.getActivity(this, 0,  
                new Intent(this, Controller.class), 0);  
        // Set the info for the views that show in the notification panel.   
        notification.setLatestEventInfo(this, getText(R.string.remote_service_label),  
                       text, contentIntent);  
        // Send the notification.   
        // We use a string id because it is a unique number.  We use it later to cancel.   
        mNM.notify(R.string.remote_service_started, notification);  
    }  
}

_Bool 处理 Boolean(即 0 或 1)  
_Complex 处理复数  
_Imaginary 处理抽象数字

volatile char *outPort;  
*outPort = 'O';  
*outPort = 'N';

typedef signed char BOOL;
#define YES (BOOL)1;
#define NO (BOOL)0;

+ (NSNumber *)numberWithChar :(char)value;
+ (NSNumber *)numberWithInt :(int)value;
+ (NSNumber *)numberWithFloat :(float)value;
+ (NSNumber *)numberWithBool :(BOOL)value;

NSNumber *number = [NSNumber numberWithInt :42];

- (char)charValue;
- (int)intValue;
- (float)floatValue;
- (BOOL)boolValue;
- (NSString *)stringValue;

+(NSValue*)valueWithBytes:(const void *) value objCType:(const char *)type;

NSRect rect = NSMakeRect(1,2,30,40);
NSValue *value;
value = [NSValuevalueWithBytes:&rect objCType:@encode(NSRect)];

value = [array objectAtIndex : 0];
[value getValue:&rect];

+ (NSValue*)valueWithPoint:(NSPoint)point;
+ (NSValue*)valueWithSize:(NSSize)size;
+ (NSValue*)valueWithRect:(NSRect)rect;
- (NSSize)sizeValue;
- (NSRect)rectValue;
- (NSPoint)pointValue;

[NSNull null] //总返回一样的值
+ (NSNull *)null;

[contast setObject:[NSNull null] forKey:@"home"];

id home = [contast objectForKey:@"home"];
if (home==[NSNullnull]){
...
}

NSFileManager *manager = [NSFileManager defaultManager] ;

NSString *home = [@"~" stringByExpandingTildeInPath];
//输出文件的扩展名
- (NSString*) pathExtension

#import <Foundation/Foundation.h>
int main (int argc, const char* argv[]) {
	NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];
	NSFileManager *manager;
	manager = [NSFileManager defaultManager];
	NSString *home;
	home = [@"~" stringByExpandingTildeInPath];
	NSDirectoryEnumerator *direnum;
	direnum = [manager enumeratorAtPath: home];
	NSMutableArray *files;
	files = [NSMutableArray arrayWithCapacity:100];
	NSString *filename;
	while (filename = [direnum nextObject]) {
		if ([[filename pathExtension] isEqualTo:@"jpg"]) {
			[files addObject: filename];
		}
	}
	NSEnumerator *fileenum;
	fileenum = [files objectEnumerator];
	while (filename = [fileenum nextObject]) {
		NSLog (@"%@", filename);
	}
	[pool drain];
	return 0;
}

***

- 文本
- 文本
- 文本

1. 文本
2. 文本
3. 文本

[简书](http://jianshu.io)

![](http://upload-images.jianshu.io/upload_images/1623602-de31fc2f960b360c.jpg?imageMogr2/auto-orient/strip%7CimageView2/2/w/1240)

> 一盏灯， 一片昏黄； 一简书， 一杯淡茶。 守着那一份淡定， 品读属于自己的寂寞。 保持淡定， 才能欣赏到最美丽的风景！ 保持淡定， 人生从此不再寂寞。

> 朝辞白帝彩云间  
> 千里江陵一日还  
> 两岸猿声啼不住  
> 轻舟已过万重山

*斜体*
**粗体**

```

```
效果

目录级关系（在某些环境不起作用）
---------
源码

效果  
+ 个人收藏
    + AirDrop
    + iCloub Drive
    - 文档
        - 书籍
            + 程序员修炼之道：从小工到专家
            + 编程珠玑
            + 算法导论
        + 笔记
        + 稿件
引用多层级关系
---------
源码

<intent-filter>
     <action android:name="android.intent.action.MAIN" /> // 启动程序优先启动
     <category android:name="android.intent.category.LAUNCHER" /> // 桌面图标
</intent-filter>

1. Main thread start
2. Create CountDownLatch for N threads
3. Create and start N threads
4. Main thread wait on latch
5. N threads completes there tasks are returns
6. Main thread resume execution

package com.atopom.jdk5.concurrent.countdownlatch;
public class _Main {
	public static void main(String[] args) {
		boolean result = false;
		try {
			result = ApplicationStartupUtil.checkExternalServices();
		} catch (Exception e) {
			e.printStackTrace();
		}
		System.out.println("External services validation completed !! Result was :: " + result);
	}
}

Checking Cache Service
Checking Database Service
Checking Network Service
Database Service is UP
Cache Service is UP
Network Service is UP
External services validation completed !! Result was :: true