Android开源代码解读の地图照片应用Panoramio的实现详解（五）

在前面几篇文章中，我们或多或少了解到了ImageManager类的存在，它负责从Panoramio服务器下载搜索区域内的图片数据，同时进行解析。当然，这一切是在独立的后台线程中进行的，下载的情况通过观察者模式通告给ImageList进行显示（ImageManager是被观察对象Subject）。注意，ImageManager是一个单例类。

本文涉及到的知识点有两个：JSON和WeakReference。

1）JSON（www.json.org）是目前流行的网络数据交换格式，它是JavaScript Object Notation的缩写。JSON数据是一系列键值对的集合，相信曾做过web开发的对这个不会陌生。Android自带的JSON API位于libcore\json\src\main\java\org\json目录中，包括JSON.java、JSONArray.java等6个Java源文件，在代码开头处有个声明可以看下：

Note: this class was written without inspecting the non-free org.json sourcecode.

可以看出，这是是Google自己实现的一个JSON解析类。

2）WeakReference是Java四种引用类型之一的弱引用，其他三种分别是强引用StrongReference，软引用SoftReference和虚引用PhantomReference（又叫幽灵引用）。这四种引用和垃圾收集器GC的交互各不相同，下面就来简单分析下：

StrongReference是Java的默认引用，它会尽可能长地存活在Java虚拟机中，当没有任何对象指向它时，GC执行后才会被回收；

SoftReference和WeakReference类似，最大的区别在于软引用会尽可能长地保留它自己，直到出现Java虚拟机内存不足时才会被回收；因此，软引用常用于对内存敏感的程序中；

WeakReference当它所引用的对象在Java虚拟机中不再存在强引用时，GC执行后弱引用才会被回收；

PhantomReference完全类似于没有引用，虚引用对对象本身没有太大影响，对象甚至感觉不到虚引用的存在。虚引用主要用于跟踪对象被垃圾回收的状态，虚引用不能单独使用，它必须和引用队列ReferenceQueue结合使用。

除了强引用外，其他几个引用对应的类都定义在Java.lang.ref包中，而且都继承自Reference类，下面看下它们的源代码吧：

package java.lang.ref;/** * Provides an abstract class which describes behavior common to all reference * objects. It is not possible to create immediate subclasses of * {@code Reference} in addition to the ones provided by this package. It is * also not desirable to do so, since references require very close cooperation * with the system's garbage collector. The existing, specialized reference * classes should be used instead. */public abstract class Reference<T> {    /**     * The object to which this reference refers.     * VM requirement: this field <em>must</em> be called "referent"     * and be an object.     */    volatile T referent;    /**     * If non-null, the queue on which this reference will be enqueued     * when the referent is appropriately reachable.     * VM requirement: this field <em>must</em> be called "queue"     * and be a java.lang.ref.ReferenceQueue.     */    @SuppressWarnings("unchecked")    volatile ReferenceQueue queue;    /**     * Used internally by java.lang.ref.ReferenceQueue.     * VM requirement: this field <em>must</em> be called "queueNext"     * and be a java.lang.ref.Reference.     */    @SuppressWarnings("unchecked")    volatile Reference queueNext;    /**     * Used internally by the VM.  This field forms a singly-linked     * list of reference objects awaiting processing by the garbage     * collector.     */    @SuppressWarnings("unchecked")    volatile Reference pendingNext;    /**     * Constructs a new instance of this class.     */    Reference() {        super();    }    /**     * Makes the referent {@code null}. This does not force the reference     * object to be enqueued.     */    public void clear() {        referent = null;    }    /**     * An implementation of .enqueue() that is safe for the VM to call.     * If a Reference object is a subclass of any of the     * java.lang.ref.*Reference classes and that subclass overrides enqueue(),     * the VM may not call the overridden method.     * VM requirement: this method <em>must</em> be called "enqueueInternal",     * have the signature "()Z", and be private.     *     * @return {@code true} if this call has caused the {@code Reference} to     * become enqueued, or {@code false} otherwise     */    @SuppressWarnings("unchecked")    private synchronized boolean enqueueInternal() {        /* VM requirement:         * The VM assumes that this function only does work         * if "(queue != null && queueNext == null)".         * If that changes, Dalvik needs to change, too.         * (see MarkSweep.c:enqueueReference())         */        if (queue != null && queueNext == null) {            queue.enqueue(this);            queue = null;            return true;        }        return false;    }    /**     * Forces the reference object to be enqueued if it has been associated with     * a queue.     *     * @return {@code true} if this call has caused the {@code Reference} to     * become enqueued, or {@code false} otherwise     */    public boolean enqueue() {        return enqueueInternal();    }    /**     * Returns the referent of the reference object.     *     * @return the referent to which reference refers, or {@code null} if the     *         object has been cleared.     */    public T get() {        return referent;    }    /**     * Checks whether the reference object has been enqueued.     *     * @return {@code true} if the {@code Reference} has been enqueued, {@code     *         false} otherwise     */    public boolean isEnqueued() {        return queueNext != null;    }}

SoftReference.java文件如下所示：

public class SoftReference<T> extends Reference<T> {    /**     * Constructs a new soft reference to the given referent. The newly created     * reference is not registered with any reference queue.     *     * @param r the referent to track     */    public SoftReference(T r) {        super();        referent = r;    }    /**     * Constructs a new soft reference to the given referent. The newly created     * reference is registered with the given reference queue.     *     * @param r the referent to track     * @param q the queue to register to the reference object with. A null value     *          results in a weak reference that is not associated with any     *          queue.     */    public SoftReference(T r, ReferenceQueue<? super T> q) {        super();        referent = r;        queue = q;    }}

接下来是WeakReference.java，它的实现几乎和SoftReference一样，只是类名不同而已：

public class WeakReference<T> extends Reference<T> {    /**     * Constructs a new weak reference to the given referent. The newly created     * reference is not registered with any reference queue.     *     * @param r the referent to track     */    public WeakReference(T r) {        super();        referent = r;    }    /**     * Constructs a new weak reference to the given referent. The newly created     * reference is registered with the given reference queue.     *     * @param r the referent to track     * @param q the queue to register to the reference object with. A null value     *          results in a weak reference that is not associated with any     *          queue.     */    public WeakReference(T r, ReferenceQueue<? super T> q) {        super();        referent = r;        queue = q;    }}

而最后的PhantomReference.java的实现稍微有点区别，它的get函数返回null：

public class PhantomReference<T> extends Reference<T> {    /**     * Constructs a new phantom reference and registers it with the given     * reference queue. The reference queue may be {@code null}, but this case     * does not make any sense, since the reference will never be enqueued, and     * the {@link #get()} method always returns {@code null}.     *     * @param r the referent to track     * @param q the queue to register the phantom reference object with     */    public PhantomReference(T r, ReferenceQueue<? super T> q) {        super();        referent = r;        queue = q;    }    /**     * Returns {@code null}.  The referent of a phantom reference is not     * accessible.     *     * @return {@code null} (always)     */    @Override    public T get() {        return null;    }}

经过上面知识点的分析，ImageManager类也就没什么其他好讲的了，直接看代码以及注释应该就很清楚了：

package com.google.android.panoramio;import org.apache.http.HttpEntity;import org.apache.http.HttpResponse;import org.apache.http.client.HttpClient;import org.apache.http.client.methods.HttpGet;import org.apache.http.impl.client.DefaultHttpClient;import org.json.JSONArray;import org.json.JSONException;import org.json.JSONObject;import android.content.Context;import android.database.DataSetObserver;import android.graphics.Bitmap;import android.os.Handler;import android.util.Log;import java.io.BufferedReader;import java.io.IOException;import java.io.InputStream;import java.io.InputStreamReader;import java.lang.ref.WeakReference;import java.net.URI;import java.util.ArrayList;public class ImageManager {   private static final String TAG = "Panoramio";        /**     * Panoramio服务API的基本URL，更多内容可见http://www.programmableweb.com/api/panoramio     */    private static final String THUMBNAIL_URL = "//www.panoramio.com/map/get_panoramas.php?order=popularity&set=public&from=0&to=20&miny=%f&minx=%f&maxy=%f&maxx=%f&size=thumbnail";    /**     * 用于后台线程将结果反馈给UI线程     */    private Handler mHandler = new Handler();    /**     * 存储ImageManager的唯一实例     */    private static ImageManager sInstance;        /**     * 存储从网络上下载的图片和相关信息     */    private ArrayList<PanoramioItem> mImages = new ArrayList<PanoramioItem>();        /**     * 存储对当前搜索结果感兴趣的观察者实例     */    private ArrayList<WeakReference<DataSetObserver>> mObservers =             new ArrayList<WeakReference<DataSetObserver>>();        /**     * 当处于下载阶段时为true，下载结束后置为false     */    private boolean mLoading;        private Context mContext;        /**     * Key for an Intent extra. The value is the zoom level selected by the user.     */    public static final String ZOOM_EXTRA = "zoom";    /**     * Key for an Intent extra. The value is the latitude of the center of the search     * area chosen by the user.     */    public static final String LATITUDE_E6_EXTRA = "latitudeE6";    /**     * Key for an Intent extra. The value is the latitude of the center of the search     * area chosen by the user.     */    public static final String LONGITUDE_E6_EXTRA = "longitudeE6";        /**     * Key for an Intent extra. The value is an item to display     */    public static final String PANORAMIO_ITEM_EXTRA = "item";        /**     * 延迟初始化，单例模式      */    public static ImageManager getInstance(Context c) {        if (sInstance == null) {            sInstance = new ImageManager(c.getApplicationContext());        }        return sInstance;    }        /**     * 注意，构造函数必须是private，保证只能通过getInstance获取该类的唯一实例      */    private ImageManager(Context c) {        mContext = c;    }        /**     * 如果目前还在下载图片信息则返回true     */    public boolean isLoading() {        return mLoading;    }        /**     * 清除所有下载内容，并通知观察者     */    public void clear() {        mImages.clear();           notifyObservers();    }        /**     * 内存中添加一个PanoramioItem实例，并通知观察者这个变化     */    private void add(PanoramioItem item) {        mImages.add(item);           notifyObservers();    }        /**     * 目前显示的PanoramioItem数目     */    public int size() {        return mImages.size();    }    /**     * 获取内存中指定索引处的PanoramioItem实例     */    public PanoramioItem get(int position) {        return mImages.get(position);    }        /**     * 绑定一个观察者(当ImageManager保存的PanoramioItem集合发生变化时通告它们)     */    public void addObserver(DataSetObserver observer) {        WeakReference<DataSetObserver> obs = new WeakReference<DataSetObserver>(observer);        mObservers.add(obs);    }        /**     * 根据新的搜索区域信息，开启独立的线程从服务器下载该区域内的图片信息     *      * @param minLong 搜索区域的最小经度     * @param maxLong 搜索区域的最大经度     * @param minLat  搜索区域的最小纬度     * @param maxLat  搜索区域的最大纬度     */    public void load(float minLong, float maxLong, float minLat, float maxLat) {        mLoading = true;        new NetworkThread(minLong, maxLong, minLat, maxLat).start();    }        /**     * 当PanoramioItem数据集发生变化时，调用这个函数通告观察者     * 同时，清除无效的观察者对象弱引用     */    private void notifyObservers() {        final ArrayList<WeakReference<DataSetObserver>> observers = mObservers;        final int count = observers.size();        for (int i = count - 1; i >= 0; i--) {            WeakReference<DataSetObserver> weak = observers.get(i);            DataSetObserver obs = weak.get();            if (obs != null) {                obs.onChanged();            } else {                observers.remove(i);            }        }            }        /**     * 这个线程实现图片数据的下载和解析     *     */    private class NetworkThread extends Thread {    //搜索区域的最大最小经纬度        private float mMinLong;        private float mMaxLong;        private float mMinLat;        private float mMaxLat;        public NetworkThread(float minLong, float maxLong, float minLat, float maxLat) {            mMinLong = minLong;            mMaxLong = maxLong;            mMinLat = minLat;            mMaxLat = maxLat;        }        @Override        public void run() {                        String url = THUMBNAIL_URL;            url = String.format(url, mMinLat, mMinLong, mMaxLat, mMaxLong);            try {                URI uri = new URI("http", url, null);                HttpGet get = new HttpGet(uri);                                HttpClient client = new DefaultHttpClient();                HttpResponse response = client.execute(get);                HttpEntity entity = response.getEntity();                String str = convertStreamToString(entity.getContent());                JSONObject json = new JSONObject(str);                parse(json);            } catch (Exception e) {                Log.e(TAG, e.toString());            }        }                /**         * 将JSON对象解析出来          */        private void parse(JSONObject json) {            try {                JSONArray array = json.getJSONArray("photos"); //JSON数组                int count = array.length();                for (int i = 0; i < count; i++) {                    JSONObject obj = array.getJSONObject(i); //JSON数组中的对象                    long id = obj.getLong("photo_id");                    String title = obj.getString("photo_title");                    String owner = obj.getString("owner_name");                    String thumb = obj.getString("photo_file_url");                    String ownerUrl = obj.getString("owner_url");                    String photoUrl = obj.getString("photo_url");                    double latitude = obj.getDouble("latitude");                    double longitude = obj.getDouble("longitude");                    Bitmap b = BitmapUtils.loadBitmap(thumb); //加载图片缩略图                    if (title == null) {                        title = mContext.getString(R.string.untitled);                    }                    //根据解析出来的数据封装PanoramioItem对象                    final PanoramioItem item = new PanoramioItem(id, thumb, b,                            (int) (latitude * Panoramio.MILLION),                            (int) (longitude * Panoramio.MILLION), title, owner,                            ownerUrl, photoUrl);                                        final boolean done = i == count - 1; //是否全部完成                                        //每解析完一项就通知UI线程                    mHandler.post(new Runnable() {                        public void run() {                            sInstance.mLoading = !done;                            sInstance.add(item);                        }                    });                }            } catch (JSONException e) {                Log.e(TAG, e.toString());            }        }        /**         * 将输入流转换成字符串形式，因此使用了字符流API(Reader)         */        private String convertStreamToString(InputStream is) {            BufferedReader reader = new BufferedReader(new InputStreamReader(is), 8*1024);            StringBuilder sb = new StringBuilder();                 String line = null;            try {                while ((line = reader.readLine()) != null) {                    sb.append(line + "\n");                }            } catch (IOException e) {                e.printStackTrace();            } finally {                try {                    is.close();                } catch (IOException e) {                    e.printStackTrace();                }            }                 return sb.toString();        }    }    }