Android中后台服务与通知的协作工作

最新推荐文章于 2021-12-15 15:18:15 发布

jxq1994

最新推荐文章于 2021-12-15 15:18:15 发布

阅读量1.2k

点赞数 2

分类专栏： android 文章标签： android

本文链接：https://blog.csdn.net/jxq1994/article/details/76167088

版权

android 专栏收录该内容

54 篇文章 1 订阅

订阅专栏

概述

现在的APP应用基本上都会有在后台运行服务，比如音乐播放器，即便你离开了当前应用它也会继续播放；QQ在你离开当前页面打开另一个应用时，一旦有新消息，它也会及时地通知给你。它们是怎么实现的呢？

Http网络连接

感谢干活集中营，为我们提供资源以及福利。我将利用其提供的API加载妹纸图片。让我们在忙碌的生活和学习中荡起双桨~

应用将在RecyclerView视图（借助内置的GridLayoutManager）中显示内容。

layout/fragment_three.xml：

<android.support.v7.widget.RecyclerView
        android:id="@+id/is_reading_recycler"
        android:layout_width="match_parent"
        android:layout_height="match_parent">
        </android.support.v7.widget.RecyclerView>

接下来在Fragment中实例化生成新建布局，并RecyclerView视图。

FragmentThree.java:

public class FragmentThree extends Fragment {
private RecyclerView mPhotoRecyclerView;

@Override
public void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setRetainInstance(true);
}
@Override
public View onCreateView(LayoutInflater inflater, ViewGroup container,Bundle savedInstanceState) {
        View v = inflater.inflate(R.layout.fragment_three,container, false);
        mPhotoRecyclerView =(RecyclerView)v.findViewById(R.id.recycler);

        mPhotoRecyclerView.setLayoutManager(new GridLayoutManager(getActivity(), 2));
        return v;
    }
}

在应用中，我们需要一个网络连接专用类。新建一个类用于对网络操作的封装。

FlickrFetchr.java:

 private static final String TAG = "FlickrFetchr";
    private Gson gson;
    /**
     * 获得网络数据（Json数据）
     * @param urlSpec
     * @return
     * @throws IOException
     */
    public byte[] getUrlBytes(String urlSpec) throws IOException{
        URL url = new URL(urlSpec);
        HttpURLConnection connection = (HttpURLConnection)url.openConnection();
        try {
            ByteArrayOutputStream out = new ByteArrayOutputStream();
            InputStream in = connection.getInputStream();
            if(connection.getResponseCode()!=HttpURLConnection.HTTP_OK){
                throw new IOException(connection.getResponseMessage()+": with"+ urlSpec);
            }
            int bytesRead = 0;
            byte[] buffer = new byte[1024];
            while ((bytesRead=in.read(buffer))>0){
                out.write(buffer,0,bytesRead);
            }
            out.close();
            return out.toByteArray();
        } finally {
            connection.disconnect();
        }

    }


    public String getUrlString(String urlSpec)throws IOException{
        return new String(getUrlBytes(urlSpec));
    }

    /**
     * 轮询网络地址获得网页数据
     * @return
     */
    public List<MeiZi.ResultsBean> fetchRecentPhotos() {
        String url = "http://gank.io/api/data/%E7%A6%8F%E5%88%A9/20/1";
        return downloadGalleryItems(url);
    }

    public List<MeiZi.ResultsBean> searchPhotos(String query) {
        String url = "http://gank.io/api/data/"+query+"/20/1";
        return downloadGalleryItems(url);
    }

    /**
     * 获得解析Json之后的List集合
     * @param url
     * @return
     */
    public List<MeiZi.ResultsBean> downloadGalleryItems(String url) {
        List<MeiZi.ResultsBean> items = new ArrayList<>();
        try {
            String jsonString = getUrlString(url);
            parseItems(items, jsonString);
            Log.i(TAG, "Received JSON: " + jsonString);
        } catch (IOException ioe) {
            Log.e(TAG, "Failed to fetch items", ioe);
        } catch (JSONException e) {
            Log.e(TAG, "Failed to parse JSON", e);
        }
        return items;
    }

    /**
     * 解析Json数据
     * @param items
     * @param data
     * @throws IOException
     * @throws JSONException
     */
    private void parseItems(List<MeiZi.ResultsBean> items, String data) throws IOException,JSONException{
        try {
            Gson gson = new Gson();
            MeiZi meizi = gson.fromJson(data,MeiZi.class);
            items.addAll(meizi.getResults());
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

这个类里面的方法应该大家都还是熟悉的吧？网络加载用的是HttpURLConnection，并没有用到Volley、OkHttp以及最近很火的Retrofit框架。

创建了URL并打开网络连接之后，我们便可循环调用read()方法读取网络数据，直到取完
为止。只要还有数据， InputStream类就会不断地输出字节流数据。数据全部取回后，关闭网络
连接，并将读取的数据写入ByteArrayOutputStream字节数组中。
虽然最重要的数据获取任务要靠getUrlBytes(String)方法完成，但getUrlString(String)
才是我们需要的方法。它负责将getUrlBytes(String)方法获取的字节数据转换为String。

获取网络使用权限

AndroidManifest.xml

<uses-permission android:name="android.permission.INTERNET" />

使用 AsyncTask 在后台线程上运行代码

使用后台线程最简便的方式是使用AsyncTask工具类。 AsyncTask创建后台线程后，我们便
可在该线程上调用doInBackground(…)方法运行代码。
在FragmentThree.java中，添加一个名为FetchItemsTask的内部类。覆盖AsyncTask.
doInBackground(…)方法，从目标网站获取数据并记录日志，

public class FragmentThree extends Fragment {
    private static final String TAG = "PhotoGalleryFragment";
    ...

    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setHasOptionsMenu(true);
        setRetainInstance(true);
        new FetchItemsTask().execute();
    }

private class FetchItemsTask extends AsyncTask<Void,Void,List<MeiZi.ResultsBean>>{

        @Override
        protected List<MeiZi.ResultsBean> doInBackground(Void... params) {

            final String query = null; // Just for testing
            if (query == null) {
                return new FlickrFetchr().fetchRecentPhotos();
            } else {
                return new FlickrFetchr().searchPhotos(query);
            }
        }

        @Override
        protected void onPostExecute(List<MeiZi.ResultsBean> resultsBeen) {
            mItems = resultsBeen;
            setupAdapter();
        }
    }
}

关于AsyncTask的用法这里不再多讲，我们在后台线程中解析完数据加入到List集合中去，然后将数据源集合填充到界面上就可以舔屏啦！

创建模型对象类

MeiZhi.java

public class MeiZi {
    /**
     * error : false
     * results : [{"_id":"59754e41421aa97de5c7c99d","createdAt":"2017-07-24T09:32:49.583Z","desc":"7-24","publishedAt":"2017-07-24T12:13:11.280Z","source":"chrome","type":"福利","url":"https://ws1.sinaimg.cn/large/610dc034gy1fhupzs0awwj20u00u0tcf.jpg","used":true,"who":"daimajia"},{"_id":"5971760e421aa90ca209c4af","createdAt":"2017-07-21T11:33:34.104Z","desc":"7-21","publishedAt":"2017-07-21T12:39:43.370Z","source":"chrome","type":"福利","url":"http://ww1.sinaimg.cn/large/610dc034ly1fhrcmgo6p0j20u00u00uu.jpg","used":true,"who":"daimajia"}]
     */

    private boolean error;
    private List<ResultsBean> results;

    public boolean isError() {
        return error;
    }

    public void setError(boolean error) {
        this.error = error;
    }

    public List<ResultsBean> getResults() {
        return results;
    }

    public void setResults(List<ResultsBean> results) {
        this.results = results;
    }

    public static class ResultsBean {
        /**
         * _id : 59754e41421aa97de5c7c99d
         * createdAt : 2017-07-24T09:32:49.583Z
         * desc : 7-24
         * publishedAt : 2017-07-24T12:13:11.280Z
         * source : chrome
         * type : 福利
         * url : https://ws1.sinaimg.cn/large/610dc034gy1fhupzs0awwj20u00u0tcf.jpg
         * used : true
         * who : daimajia
         */

        private String _id;
        private String createdAt;
        private String desc;
        private String publishedAt;
        private String source;
        private String type;
        private String url;
        private boolean used;
        private String who;

        public String get_id() {
            return _id;
        }

        public void set_id(String _id) {
            this._id = _id;
        }

        public String getCreatedAt() {
            return createdAt;
        }

        public void setCreatedAt(String createdAt) {
            this.createdAt = createdAt;
        }

        public String getDesc() {
            return desc;
        }

        public void setDesc(String desc) {
            this.desc = desc;
        }

        public String getPublishedAt() {
            return publishedAt;
        }

        public void setPublishedAt(String publishedAt) {
            this.publishedAt = publishedAt;
        }

        public String getSource() {
            return source;
        }

        public void setSource(String source) {
            this.source = source;
        }

        public String getType() {
            return type;
        }

        public void setType(String type) {
            this.type = type;
        }

        public String getUrl() {
            return url;
        }

        public void setUrl(String url) {
            this.url = url;
        }

        public boolean isUsed() {
            return used;
        }

        public void setUsed(boolean used) {
            this.used = used;
        }

        public String getWho() {
            return who;
        }

        public void setWho(String who) {
            this.who = who;
        }
    }

}

我们其实只需要使用GsonFormat这个插件就可以自动为我们生成Bean类。

从 AsyncTask 回到主线程

我们回到视图层部分，实现在FragmentThree类的RecyclerView中显示图片标题。
首先定义一个ViewHolder内部类。

public class FragmentThree extends Fragment {
private static final String TAG = "PhotoGalleryFragment";
...

   class PhotoHolder extends RecyclerView.ViewHolder{
            private ImageView mItemImageView;
            public PhotoHolder(View itemView) {
                super(itemView);
                mItemImageView = (ImageView)itemView.findViewById(R.id.fragment_photo_gallery_image_view);
            }
            public void bindGalleryItem(MeiZi.ResultsBean item) {
                Glide.with(itemView.getContext())
                .load(item.getUrl())
                .asBitmap()
                .placeholder(R.drawable.ic_action_photo)
                .into(mItemImageView);
            }
        }
...

}

接下来，添加一个 RecyclerView.Adapter 实现，提供基于Item 对象 List 的
PhotoHolder。

public class FragmentThree extends Fragment {
private static final String TAG = "PhotoGalleryFragment";
...

private class PhotoAdapter extends RecyclerView.Adapter<PhotoAdapter.PhotoHolder> {
        private List<MeiZi.ResultsBean> mGalleryItems;

        public PhotoAdapter(List<MeiZi.ResultsBean> galleryItems) {
                mGalleryItems = galleryItems;
        }

        @Override
        public PhotoHolder onCreateViewHolder(ViewGroup parent, int viewType) {
            LayoutInflater inflater = LayoutInflater.from(getActivity());
            View view = inflater.inflate(R.layout.fragment_three_item_layout, parent, false);
            return new PhotoHolder(view);
        }

        @Override
        public void onBindViewHolder(PhotoHolder holder, int position) {
            MeiZi.ResultsBean galleryItem = mGalleryItems.get(position);
            holder.bindGalleryItem(galleryItem);
        }

        @Override
        public int getItemCount() {
            return mGalleryItems.size();
        }

        class PhotoHolder extends RecyclerView.ViewHolder{
            ...

        }
    }
    ...
}

既然RecyclerView要显示的数据已准备就绪，那么接下来编码完成adapter的配置和关联。实现setupAdapter()方法。

public class FragmentThree extends Fragment {
    private static final String TAG = "PhotoGalleryFragment";
    private RecyclerView mPhotoRecyclerView;
    private List<MeiZi.ResultsBean> mItems = new ArrayList<>();
    ...

@Nullable
    @Override
    public View onCreateView(LayoutInflater inflater, @Nullable ViewGroup container, @Nullable Bundle savedInstanceState) {
       ...

        setupAdapter();
        return v;

 private void setupAdapter() {
        if (isAdded()) {
            mPhotoRecyclerView.setAdapter(new PhotoAdapter(mItems));
        }
    }
    ...

}

注意，配置adapter前，应检查isAdded()的返回值是否为true。该检查确认fragment已与目
标activity相关联，进而保证getActivity()方法返回结果不为空。

启动应用程序，我们现在就可以看到福利啦！！那位同学把鼻血擦一擦。

后台服务

我们将为应用添加一项新功能，允许在后台下载新的网络数据。一旦干货集中营有了新的图片，用户就能在状态栏接收到通知消息。

创建 IntentService

首先来创建服务。我们将使用IntentService。 IntentService并不是Android提供的唯一服务，但可能是最常用的。创建一个名为PullService的IntentService子类，它就是用来轮询搜索结果的服务。

PullService.java :

public class PullService extends IntentService {
private static final String TAG = "PollService";
public static Intent newIntent(Context context) {
return new Intent(context, PollService.class);
}
public PullService() {
super(TAG);
}
@Override
protected void onHandleIntent(Intent intent) {
Log.i(TAG, "Received an intent: " + intent);
}
}

IntentService的用法也不多讲，前面对它也有过介绍。

在manifest配置文件中添加服务。

<manifest xmlns:android="http://schemas.android.com/apk/res/android"
package="com.bignerdranch.android.photogallery" >
<uses-permission android:name="android.permission.INTERNET" />
<application
... >
<activity
android:name=".MainActivity"
android:label="@string/app_name" >
...
</activity>
<service android:name=".PullService" />
</application>
</manifest>

在FragmentThree中添加服务启动代码：

public class FragmentThreeextends Fragment {
private static final String TAG = "PhotoGalleryFragment";
...
@Override
public void onCreate(Bundle savedInstanceState) {
...
updateItems();
Intent i = PollService.newIntent(getActivity());
getActivity().startService(i);
...
}
...
}

运行应用，查看LogCat窗口，可看到类似以下的结果。

02-23 14:25:32.450 2692-2717/com.xxx.android.photogallery I/PullService:
Received an intent: Intent { cmp=com.xxx.android.photogallery/.PullService }

安全的后台网络连接

服务将在后台轮询网站。为保证后台网络连接的安全性，我们需进一步完善代码。
Android为用户提供了关闭后台应用网络连接的功能。对于非常耗电的应用而言，这项功能可极
大地改善手机的续航。
然而，这也意味着在后台连接网络时，需使用ConnectivityManager确认网络连接是否可用。

PullService.java :

public class PollService extends IntentService {
private static final String TAG = "PollService";
...
@Override
protected void onHandleIntent(Intent intent) {
if (!isNetworkAvailableAndConnected()) {
return;
}
Log.i(TAG, "Received an intent: " + intent);
}
private boolean isNetworkAvailableAndConnected() {
ConnectivityManager cm =
(ConnectivityManager) getSystemService(CONNECTIVITY_SERVICE);
boolean isNetworkAvailable = cm.getActiveNetworkInfo() != null;
boolean isNetworkConnected = isNetworkAvailable &&
cm.getActiveNetworkInfo().isConnected();
return isNetworkConnected;
}
}

检查网络是否可用的逻辑在isNetworkAvailableAndConnected()方法中。使用后台数据设
置选项关闭后台数据下载后，后台服务也就无法联网了。这样， ConnectivityManager.
getActiveNetworkInfo()就会返回null值；这就相当于告诉后台服务网络不可用，即使设备实际
是可以联网的。
如果后台服务能够使用网络，它会得到一个代表当前网络连接的android.net.NetworkInfo
实例。然后还要调用NetworkInfo.isConnected()方法检查当前网络是否已完全连接。
如果应用找不到可用网络，或者设备没有完全连上网， onHandleIntent(…)方法就会直接
返回（不会尝试去下载数据了，如果这个方法添加了数据下载代码的话）。这个做法是个好习惯：
网都连不上，还谈什么数据下载。
不要忘了，要使用 getActiveNetworkInfo() 方法，还要在 manifest 配置文件中获取
ACCESS_NETWORK_STATE权限。

<manifest xmlns:android="http://schemas.android.com/apk/res/android"
package="com.bignerdranch.android.photogallery" >
<uses-permission android:name="android.permission.INTERNET" />
<uses-permission android:name="android.permission.ACCESS_NETWORK_STATE" />
<application
... >
...
</application>
</manifest>

查找最新返回结果

后台服务会一直查看最新返回结果，因此它要知道最近一次的获取结果。使用
SharedPreferences保存结果值再合适不过了。
创建QueryPreferences类以存储最近一次获取图片的ID。

QueryPreferences.java :

public class QueryPrefrences{
    private static final String PREF_SEARCH_QUERY = "searchQuery";
    private static final String PREF_LAST_RESULT_ID = "lastResultId";
    private static final String PREF_IS_ALARM_ON = "isAlarmOn";

    public static String getStoresQuery(Context context){
        return PreferenceManager.getDefaultSharedPreferences(context)
                .getString(PREF_SEARCH_QUERY,null);
    }

    public static void setStoreQuery(Context context,String query){
            PreferenceManager.getDefaultSharedPreferences(context)
                    .edit()
                    .putString(PREF_SEARCH_QUERY,query)
                    .apply();
    }

    /**
     * 获取上一次结果ID
     * @param context
     */
    public static String getLastResultId(Context context){
        return PreferenceManager.getDefaultSharedPreferences(context)
                .getString(PREF_LAST_RESULT_ID,null);
    }

    /**
     * 存储上一次结果ID
     * @param context
     * @param lastResultId
     */
    public static void setLastResultId(Context context,String lastResultId){
        PreferenceManager.getDefaultSharedPreferences(context)
                .edit()
                .putString(PREF_LAST_RESULT_ID,lastResultId)
                .apply();
    }


}

接下来就是完善服务代码了。以下为需要处理的任务：

 从默认SharedPreferences中获取当前查询结果以及上一次结果ID；
 使用FlickrFetchr类获取最新结果集；
 如果有结果返回，抓取第一条结果；
 确认是否不同于上一次结果ID；
 将第一条结果存入SharedPreferences。

回到PullService.java中，添加以上任务的实现代码。

PullService.java :

public class PullService extends IntentService {
private static final String TAG = "PullService";
...
@Override
protected void onHandleIntent(Intent intent) {
...
Log.i(TAG, "Received an intent: " + intent);

String lastResultId = QueryPreferences.getLastResultId(this);
List<GalleryItem> items;
items = new FlickrFetchr().fetchRecentPhotos();
if (items.size() == 0) {
return;
}
String resultId = items.get(0).getId();
if (resultId.equals(lastResultId)) {
Log.i(TAG, "Got an old result: " + resultId);
} else {
Log.i(TAG, "Got a new result: " + resultId);
}
QueryPreferences.setLastResultId(this, resultId);
}
...
}

运行应用，可看到应用首先获取了最新结果。当然很可能并没有什么变化，因为网站上的数据并没有更新。

使用 AlarmManager 延迟运行服务

在没有activity运行的情况下，为在后台运行服务，得想个办法启动它。比如说，设置一个5分钟间隔的定时器。

一种方式是调用Handler的sendMessageDelayed(…)或postDelayed(…)方法。但如果用户离开当前应用，进程就会停止， Handler消息也会随之消亡，因此该解决方案并不可靠。

Handler不行，我们还可以用AlarmManager。AlarmManager是可以发送Intent的系统服务。如何将要发送的intent告诉AlarmManager呢？使用PendingIntent。使用PendingIntent打包一个intent：“我想启动PullService服务。”然后，将其发送给系统中的其他部件，如AlarmManager。

在PullService类中，实现一个启停定时器的setServiceAlarm(Context,boolean)方法，该方法是个静态方法。这样，定时器代码和与之相关的代码就可以放在一起了，同时，其他系统部件还可以调用到它。要知道，定时器通常是从前端的fragment或其他控
制层代码中启停的。

PullService.java :

public class PullService extends IntentService {
private static final String TAG = "PullService";
private static final int POLL_INTERVAL = 1000 * 60; // 60 seconds
public static Intent newIntent(Context context) {
return new Intent(context, PollService.class);
}
public static void setServiceAlarm(Context context, boolean isOn) {
Intent i = PollService.newIntent(context);
PendingIntent pi = PendingIntent.getService(context, 0, i, 0);
AlarmManager alarmManager = (AlarmManager)
context.getSystemService(Context.ALARM_SERVICE);
if (isOn) {
alarmManager.setInexactRepeating(AlarmManager.ELAPSED_REALTIME,
SystemClock.elapsedRealtime(), POLL_INTERVAL, pi);
} else {
alarmManager.cancel(pi);
pi.cancel();
}
}
...
}

以上代码中，首先是调用PendingIntent.getService(…)方法，创建一个用来启动PullService的PendingIntent。 PendingIntent.getService(…)方法打包了一个Context.startService(Intent)方法的调用。

它有四个参数：一个用来发送intent的Context，一个区分PendingIntent来源的请求代码，一个待发送的Intent对象以及一组用来决定如何创建PendingIntent的标志符。（稍后会使用其中的一个。）

接下来，需要设置或取消定时器。

FragmentThree.java :

public class FragmentThree extends Fragment {
private static final String TAG = "PhotoGalleryFragment";
...
@Override
public void onCreate(Bundle savedInstanceState) {
...
updateItems();
Intent i = PollService.newIntent(getActivity());
getActivity().startService(i);
PollService.setServiceAlarm(getActivity(), true);
...
}
...
}

使用 PendingIntent 管理定时器

一个PendingIntent只能登记一个定时器。这也是isOn值为false时， setServiceAlarm(Context, boolean)方法的工作原理：

首先调用AlarmManager.cancel(PendingIntent)方法撤销PendingIntent的定时器，然后撤销PendingIntent。

既然撤销定时器也随即撤消了PendingIntent，可通过检查PendingIntent是否存在来确认定时器激活与否。

具体代码实现时，传入 PendingIntent.FLAG_NO_CREATE 标志给PendingIntent.getService(…)方法即可。该标志表示如果PendingIntent不存在，则返回null，而不是创建它。

添加一个名为isServiceAlarmOn(Context)的新方法，并传入PendingIntent.FLAG_NO_CREATE标志，以判断定时器的启停状态。

PullService .java:

public class PullService extends IntentService {
...
public static void setServiceAlarm(Context context, boolean isOn) {
...
}
/**
     * 判断PenddingIntent是否为空
     * 如果为空，则定时器未启动，返回false
     */
public static boolean isServiceAlarmOn(Context context) {
Intent i = PollService.newIntent(context);
PendingIntent pi = PendingIntent
.getService(context, 0, i, PendingIntent.FLAG_NO_CREATE);
return pi != null;
}
...
}

这里的PendingIntent仅用于设置定时器，因此PendingIntent空值表示定时器还未设置。

控制定时器

既然可以开关定时器（也能判定其启停状态），接下来就通过图形界面对其进行开关控制。
首先添加另一菜单项。

menu/is_reading_menu.xml：

<?xml version="1.0" encoding="utf-8"?>
<menu xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:app="http://schemas.android.com/apk/res-auto">
    <item android:id="@+id/menu_item_toggle_polling"
        android:title="@string/start_polling"
        app:showAsAction="ifRoom" />
</menu>

添加字符串资源

<string name="start_polling">Start polling</string>
<string name="stop_polling">Stop polling</string>
<string name="new_pictures_title">New PhotoGallery Pictures</string>
<string name="new_pictures_text">You have new pictures in PhotoGallery.</string>

菜单项切换实现

FragmentThree.java :

private static final String TAG = "PhotoGalleryFragment";
...
@Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
...
updateItems();
// PollService.setServiceAlarm(getActivity(), true);

...
}
...
 @Override
    public boolean onOptionsItemSelected(MenuItem item) {
        switch (item.getItemId()) {
            case R.id.menu_item_toggle_polling:
                boolean shouldStartAlarm = !PullService.isServiceAlarmOn(getActivity());
                PullService.setServiceAlarm(getActivity(), shouldStartAlarm);
                getActivity().invalidateOptionsMenu(); //刷新工具栏菜单
                return true;
            default:
                return super.onOptionsItemSelected(item);
        }

    }
}
...

完成代码添加后，就应该可以启停定时器了。然而，你可能已经注意到，即使定时器已经启动了， polling选项菜单也总是显示着Start polling。我们应该更新选项菜单，以准确反映定时器启停状态。

在onCreateOptionsMenu(…)方法中，检查定时器的开关状态，然后相应地更新menu_item_toggle_polling的标题文字，反馈正确的信息给用户。

public class FragmentThree extends Fragment {
private static final String TAG = "PhotoGalleryFragment";
...
 @Override
    public void onCreateOptionsMenu(Menu menu, MenuInflater inflater) {
        super.onCreateOptionsMenu(menu, inflater);
        inflater.inflate(R.menu.is_reading_menu, menu);

        MenuItem toggleItem = menu.findItem(R.id.menu_item_toggle_polling);
        if (PullService.isServiceAlarmOn(getActivity())) {
            toggleItem.setTitle(R.string.stop_polling);
        } else {
            toggleItem.setTitle(R.string.start_polling);
        }
    }
    ...
}

通知信息

后台的服务完成了，但是用户对此毫不知情，因此我们需要服务与用户进行沟通。

首先是基础代码准备。在MainActivity.java中，添加一个newIntent(…)静态方法，该静态方法会返回一个可用来启动PhotoGalleryActivity的Intent实例。（最后， PullService会调用这个方法，把返回结果封装在一个PendingIntent中，然后设置给通知消息。）

MainActivity.java :

public class MainActivity extends AppCompatActivity {
public static Intent newIntent(Context context) {
return new Intent(context, PhotoGalleryActivity.class);
}
...
}

一旦有了新结果，就让PullService通知用户。也就是说，创建一个Notification对象，然后调用NotificationManager.notify(int, Notification)方法。

PullService.java :

public class PullService extends IntentService {
...
@Override
 protected void onHandleIntent(Intent intent) {
        Log.i(TAG, "Received an intent: " + intent);
        if(!isNetworkAvailableAndConnected()){
            return;
        }
        //获得上一次结果的第一条数据的ID
        String lastResultId = QueryPrefrences.getLastResultId(this);
        List<MeiZi.ResultsBean> items = new ArrayList<>();
        //获取最新返回集
        items = new FlickrFetchr().fetchRecentPhotos();

        if (items.size() == 0) {
            return;
        }
        //如果有结果，抓取第一条结果
        String resultId = items.get(0).get_id();
        /**
         * 确认是否不同于上一次结果id
         */
        if(resultId.equals(lastResultId)){
            Log.i(TAG, "Got an old result: " + resultId);
        }else{
            Log.i(TAG, "Got a new result: " + resultId);
            /**
             * 发送一条通知
             */
            Resources resources = getResources();
            Intent i = MainActivity.newIntent(this);
            PendingIntent pi = PendingIntent.getActivity(this,0,i,0);

            Notification notification = new NotificationCompat.Builder(this)
                                        .setTicker(resources.getString(R.string.new_pictures_title))
                                        .setSmallIcon(android.R.drawable.ic_menu_report_image)
                                        .setContentTitle(resources.getString(R.string.new_pictures_title))
                                        .setContentText(resources.getString(R.string.new_pictures_text))
                                        .setContentIntent(pi)
                                        .setAutoCancel(true)
                                        .build();

            NotificationManagerCompat notificationManager = NotificationManagerCompat.from(this);
            notificationManager.notify(0,notification);
        }
        //将第一条结果存入SharedPreference
        QueryPrefrences.setLastResultId(this, resultId);

    }
...
}

运行应用并打开polling服务。不一会儿，应该就会看到状态栏的通知图标。拉开通知抽屉，就会看到后台服务发送的新结果消息。
既然后台服务已能正常工作，那就改用一个更为合理的定时器常量。

public class PullService extends IntentService {u
private static final String TAG = "PollService";
//public static final int POLL_INTERVAL = 1000 * 60; // 60 seconds
private static final long POLL_INTERVAL = AlarmManager.INTERVAL_FIFTEEN_MINUTES;
...
}

最后的结果就是这样啦！如下所示：

查看Log可以发现，服务一致在后台运行，对网站进行轮询。获得最新的一次返回结果。

这里写图片描述

一旦有了最新的结果，我们就会在通知栏收到一条通知。

这里写图片描述

点击通知将回跳到我们的界面，还记得在MainActivity里面添加的NewIntent（）方法吗？我们将打开MainActivity。

这里写图片描述

源代码地址

jxq1994

关注

2
点赞
踩
2

收藏

觉得还不错? 一键收藏
0
评论
Android中后台服务与通知的协作工作

概述现在的APP应用基本上都会有在后台运行服务，比如音乐播放器，即便你离开了当前应用它也会继续播放；QQ在你离开当前页面打开另一个应用时，一旦有新消息，它也会及时地通知给你。它们是怎么实现的呢？Http网络连接感谢干活集中营，为我们提供资源以及福利。我将利用其提供的API加载妹纸图片。让我们在忙碌的生活和学习中荡起双桨~应用将在RecyclerView视图（借助内置的GridLayoutManag
复制链接

扫一扫

专栏目录