从Foursquare看手机端程序设计

   By 姜跃 Jiangyue.hust@gmail.com

外国人真具有共产主义精神，Foursquare都拿出开源了，不像国内某些公司。Foursquare下载地址主页地址http://code.google.com/p/foursquared/ 。下载方式hg clone https://foursquared.googlecode.com/hg/ foursquared ，在linux下用hg命令可以直接下载。Foursquare在代码组织方面当然是相当不错的，层次逻辑规划的相当好，在解决网络读写时的界面阻塞，以及图片加载等耗时操作方面采用的方式值得借鉴。下面以传输协议，图片加载，网络读取方面介绍。

 

一．协议层

Foursquare采用http协议传输数据。目前如Foursquare，twitter都采用如手机+浏览器+iPad等诸多设备，为了服务器的统一，采用http协议。

Foursquare中的基类HttpApi定义了Http协议的一些接口doHttpRequest，及doHttpPost，AbstractHttpApi则实现了上述方法。Foursquare与服务器交换数据的格式采用XML格式。Foursquare客户端要获取数据时首先构造好http请求，通过http层的doHttpRequest，及doHttpPost层发送http请求，服务器解析http请求，把结果保存为XML格式返回给客户端。以City类来解释XML解析过程，过程中涉及四个类，AbstractParser解析基类，主要用户构造解析器基类，提供解析方法，CityParser继承自AbstractParser，用于解析一条协议，FoursqureType接口无函数定义，用于表示是一个Foursqure类型，City继承于FoursqureType表示一个解析结果。

解析方式中采用了设计模式中的模板模式—定义一个操作中的算法骨架，而将进一步实现延迟到子类中，子类不改变一个算法的结构即可中定义改算法的某些特定步骤，达到复用代码的目的。

在AbstractParser类中定义了解析算法的模板，并且定义了抽象方法abstract protected T parseInner()用于解析一个具体的协议。我们来看模板方法：

public final T parse(XmlPullParser parser) throws FoursquareParseException, FoursquareError { // /算法模 try { if (parser.getEventType() == XmlPullParser.START_DOCUMENT) { parser.nextTag(); if (parser.getName().equals("error")) { throw new FoursquareError(parser.nextText()); } } return parseInner(parser); // 调用子类具体实现 } catch (IOException e) { if (DEBUG) LOG.log(Level.FINE, "IOException", e); throw new FoursquareParseException(e.getMessage()); } catch (XmlPullParserException e) { if (DEBUG) LOG.log(Level.FINE, "XmlPullParserException", e); throw new FoursquareParseException(e.getMessage()); } }

 

再看下CityParser 子类具体解析的过程：

服务器返回的结果

<?xml version=”1.0”?> <city> < geolat ></ geolat > < geolong ></ geolong > < id ></ id > < name ></ name > < shortname ></ shortname > < timezone ></ timezone > < cityid ></ cityid > </city>

CityParser中的parseInner解析过程

parser.require(XmlPullParser.START_TAG, null, null); City city = new City(); //解析结果 while (parser.nextTag() == XmlPullParser.START_TAG) { String name = parser.getName(); if ("geolat".equals(name)) { city.setGeolat(parser.nextText()); }else if ("geolong".equals(name)) { city.setGeolong(parser.nextText()); }else if ("id".equals(name)) { city.setId(parser.nextText()); }else if ("name".equals(name)) { city.setName(parser.nextText()); }else if ("shortname".equals(name)) { city.setShortname(parser.nextText()); }else if ("timezone".equals(name)) { city.setTimezone(parser.nextText()); }else if ("cityid".equals(name)) { city.setId(parser.nextText()); }else { skipSubTree(parser); } } return city;

Foursquare中要新添加一条协议的时候只要继承AbstractParser并实现其中的parseInner方法，实现FoursqureType定义一个新的类型就可以了。采用模板方法，无疑提高了系统的可扩展性，以及清晰地代码结构，容易维护，这就是采用面向对象思想带来的好处。

二．图标读取优化 延迟加载+缓存+多线程读取+线程池技术

考虑到手机带宽的限制，以及提升性能，缓存是必不可少的组件。在手机端缓存，主要用户缓存一些常用的不易改变的图片，如：地点，用户，朋友头像等。来分析下缓存的具体实现。缓存实现主要在BaseDiskCache类中。

//用于存放一个图片到缓存中

 

public void store(String key, InputStream is) { if (DEBUG) Log.d(TAG, "store: " + key); is = new BufferedInputStream(is); try { OutputStream os = new BufferedOutputStream(new FileOutputStream(getFile(key)));//获取存放路径 byte[] b = new byte[2048]; int count; int total = 0; while ((count = is.read(b)) > 0) { os.write(b, 0, count); total += count; } os.close(); if (DEBUG) Log.d(TAG, "store complete: " + key); } catch (IOException e) { if (DEBUG) Log.d(TAG, "store failed to store: " + key, e); return; } } //获取路径 public File getFile(String hash) { return new File(mStorageDirectory.toString() + File.separator + hash); //存放路径 }

为了提升手机端的响应速度，Foursquare采用了一种巧妙的措施，Foursquare在获取一个带图片的列表的时候，图片和文字区别对待。Foursquare先获取文字列表并显示出文字，而图片则是延迟加载。在加载图片的过程采用了缓存+多线程+线程池等技术优化读取速度。Foursquare读取图片的时候采用多线程技术，同时几个线程读取图片，并把读到的图片缓存起来，以便下次读取。读到图片以后通知界面更新。

图标读取优化是Foursquare中最为复杂的技术之一。在分析之前应该先掌握以下基础知识：

1.观察者模式。在此种模式中，一个目标物件管理所有相依于它的观察者物件，并且在它本身的状态改变时主动发出通知。

详见http://baike.baidu.com/view/1854779.htm?fr=ala0_1

2.ExecutorService是java中用于管理一个线程池的类，使用实例参见

http://hi.baidu.com/coolinc/blog/item/0d5545d48c9183ce50da4bcf.html

3.Android notifyDataSetChanged() 方法：notifyDataSetChanged方法通过一个外部的方法控制如果适配器的内容改变时需要强制调用getView来刷新每个Item的内容。

图片读取主要有四个类组成FetcherObserver 是RemoteResourceFetcher的Observer，等待RemoteResourceFetcher获取的数据后调用RemoteResourceManager中的notifyObservers()通知RemoteResourceManagerObserver更新界面。

       RemoteResourceFetcher 通过网络以多线程的方式获取数据。获取图片代码：

ExecutorService mExecutor;

       mExecutor = Executors.newCachedThreadPool(); //创建线程池

public Future<Request> fetch(Uri uri, String hash) {

        Request request = new Request(uri, hash);

        synchronized (mActiveRequestsMap) {

            Callable<Request> fetcher = newRequestCall(request); //构造http请求

            if (mActiveRequestsMap.putIfAbsent(request, fetcher) == null) {

                if (DEBUG) Log.d(TAG, "issuing new request for: " + uri);

                return mExecutor.submit(fetcher);       //执行线程

            } else {

                if (DEBUG) Log.d(TAG, "Already have a pending request for: " + uri);

            }

        }

        return null;

    }

//构造的读取请求

private Callable<Request> newRequestCall(final Request request) {

        return new Callable<Request>() {

            public Request call() {

                try {

                    if (DEBUG) Log.d(TAG, "Requesting: " + request.uri);

                    HttpGet httpGet = new HttpGet(request.uri.toString());

                    httpGet.addHeader("Accept-Encoding", "gzip");

                    HttpResponse response = mHttpClient.execute(httpGet); //执行http请求

                    HttpEntity entity = response.getEntity();

                    InputStream is = getUngzippedContent(entity);

                    mResourceCache.store(request.hash, is); //获取的数据存入到缓存中

                    if (DEBUG) Log.d(TAG, "Request successful: " + request.uri);

                } catch (IOException e) {

                    if (DEBUG) Log.d(TAG, "IOException", e);

                } finally {

                    if (DEBUG) Log.d(TAG, "Request finished: " + request.uri);

                    mActiveRequestsMap.remove(request);

                    notifyObservers(request.uri);          //通知所有Observer 这里通知的是 FetcherObserver对象

                }

                return request;

            }

       };

}

FetcherObserver 监视RemoteResourceFetcher 并调用RemoteResourceManager

中的notifyObservers() 通知 RemoteResourceManager 中注册的Observer对象

public void update(Observable observable, Object data) {

            setChanged();

            notifyObservers(data); // 调用RemoteResourceManager中的notifyObservers通知RemoteResourceManagerObserver更新数据

}

RemoteResourceManager 管理缓存，并通知RemoteResourceManagerObserver

RemoteResourceManagerObserver调用更新方法更新界面

private class RemoteResourceManagerObserver implements Observer {

        @Override

        public void update(Observable observable, Object data) {

            if (DEBUG) Log.d(TAG, "Fetcher got: " + data);

            mHandler.post(new Runnable() {

                @Override

                public void run() {

                    notifyDataSetChanged();   // 通知android界面更新

                }

            });

        }

    }

 

 

三．AsyncTask解决网络读取的界面阻塞

手机从服务器获取数据的时候，是一个较耗时的操作，为了在获取网络读取的时候不阻塞用户操作，AsyncTask。为什么不采用多线程呢？

       采用线程的方式方式是存在缺陷的：第一，线程的开销较大，如果每个任务都要创建一个线程，那么应用程序的效率要低很多；第二，线程无法管理，匿名线程创建并启动后就不受程序的控制了，如果有很多个请求发送，那么就会启动非常多的线程，系统将不堪重负。另外，前面已经看到，在新线程中更新UI还必须要引入handler，这让代码看上去非常臃肿。
        为了解决这一问题，android在1.5版本引入了AsyncTask。AsyncTask的特点是任务在主线程之外运行，而回调方法是在主线程中执行，这就有效地避免了使用Handler带来的麻烦。阅读AsyncTask的源码可知，AsyncTask是使用java.util.concurrent框架来管理线程以及任务的执行的，concurrent框架是一个非常成熟，高效的框架，经过了严格的测试。这说明AsyncTask的设计很好的解决了匿名线程存在的问题。
        AsyncTask是抽象类，子类必须实现抽象方法doInBackground(Params... p) ，在此方法中实现任务的执行工作，比如连接网络获取数据等。通常还应该实现onPostExecute(Result r)方法，因为应用程序关心的结果在此方法中返回。需要注意的是AsyncTask一定要在主线程中创建实例。AsyncTask定义了三种泛型类型Params，Progress和Result。

•Params 启动任务执行的输入参数，比如HTTP请求的URL。
•Progress 后台任务执行的百分比。
•Result 后台执行任务最终返回的结果，比如String。
•AsyncTask的执行分为四个步骤，与前面定义的TaskListener类似。每一步都对应一个回调方法，需要注意的是这些方法不应该由应用程序调用，开发者需要做的就是实现这些方法。在任务的执行过程中，这些方法被自动调用。
•onPreExecute() 当任务执行之前开始调用此方法，可以在这里显示进度对话框。
•doInBackground(Params...) 此方法在后台线程执行，完成任务的主要工作，通常需要较长的时间。在执行过程中可以调用publicProgress(Progress...)来更新任务的进度。
•onProgressUpdate(Progress...) 此方法在主线程执行，用于显示任务执行的进度。
•onPostExecute(Result) 此方法在主线程执行，任务执行的结果作为此方法的参数返回。

private static class CheckinTask extends AsyncTask<Void, Void, CheckinResult> {

        protected void onPreExecute() {

            mActivity.startProgressBar(mActivity.getResources().getString(

                    R.string.checkin_action_label), mActivity.getResources().getString(

                    R.string.checkin_execute_activity_progress_bar_message));

        }

protected CheckinResult doInBackground(Void... params) {

         Foursquared foursquared = (Foursquared) mActivity.getApplication();

       Foursquare foursquare = foursquared.getFoursquare();

        CheckinResult result =

                  foursquare.checkin(     //网络读取 异步执行

                    mVenueId,

                    null,

                    LocationUtils.createFoursquareLocation(mLocation),

                    mShout,

                   !mTellFriends, // (isPrivate)

                    mTellFollowers,

                    mTellTwitter,

                    mTellFacebook);

    

        }

        protected void onPostExecute(CheckinResult result) {

            if (DEBUG) Log.d(TAG, "CheckinTask: onPostExecute()");

            if (mActivity != null) {

                mActivity.onCheckinComplete(result, mReason);

            }

        }

        protected void onCancelled() {

            if (mActivity != null) {

                mActivity.onCheckinComplete(null, new Exception(

                        "Check-in cancelled."));

            }

        }

    }

四．总结

从Foursquare客户端的设计可以看到，以手机客户端与服务器传输采用http以及XML格式，方便兼容浏览器及ipad等平板设备，减少重复开发。为了良好的用户体验，坚决要采用异步的方式，采用同步阻塞方式读取请求，在读取的时候用户无法操作，大大消弱了用户体验。在传输图片等耗费时间的操作，采用延迟加载+缓存+多线程读取+线程池技术解决，能够达到良好的速度及用户体验。为了达到代码复用及系统的维护，可以采用设计模式等。总之Foursquare代码是一个相当好的商业级手机应用软件学习的例子。在仔细分析它的代码结构，以及在一些问题上采用的解决方案，对设计能力及技术上有很大提高。在分析的时候应该看到更深层次设计上的东西，这些东西是脱离语言脱离平台而存在的，把这些不变东西积淀下来，才是真正的成长，以后再遇到任何平台都可以轻松编写程序。