to top
BasicSyncAdapter / src / com.example.android.basicsyncadapter /

EntryListFragment.java

1
/*
2
 * Copyright 2013 The Android Open Source Project
3
 *
4
 * Licensed under the Apache License, Version 2.0 (the "License");
5
 * you may not use this file except in compliance with the License.
6
 * You may obtain a copy of the License at
7
 *
8
 *      http://www.apache.org/licenses/LICENSE-2.0
9
 *
10
 * Unless required by applicable law or agreed to in writing, software
11
 * distributed under the License is distributed on an "AS IS" BASIS,
12
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13
 * See the License for the specific language governing permissions and
14
 * limitations under the License.
15
 */
16
 
17
package com.example.android.basicsyncadapter;
18
 
19
import android.accounts.Account;
20
import android.annotation.TargetApi;
21
import android.app.Activity;
22
import android.content.ContentResolver;
23
import android.content.Intent;
24
import android.content.SyncStatusObserver;
25
import android.database.Cursor;
26
import android.net.Uri;
27
import android.os.Build;
28
import android.os.Bundle;
29
import android.support.v4.app.ListFragment;
30
import android.support.v4.app.LoaderManager;
31
import android.support.v4.content.CursorLoader;
32
import android.support.v4.content.Loader;
33
import android.support.v4.widget.SimpleCursorAdapter;
34
import android.text.format.Time;
35
import android.util.Log;
36
import android.view.Menu;
37
import android.view.MenuInflater;
38
import android.view.MenuItem;
39
import android.view.View;
40
import android.widget.ListView;
41
import android.widget.TextView;
42
 
43
import com.example.android.common.accounts.GenericAccountService;
44
import com.example.android.basicsyncadapter.provider.FeedContract;
45
 
46
/**
47
 * List fragment containing a list of Atom entry objects (articles) stored in the local database.
48
 *
49
 * <p>Database access is mediated by a content provider, specified in
50
 * {@link com.example.android.basicsyncadapter.provider.FeedProvider}. This content
51
 * provider is
52
 * automatically populated by  {@link SyncService}.
53
 *
54
 * <p>Selecting an item from the displayed list displays the article in the default browser.
55
 *
56
 * <p>If the content provider doesn't return any data, then the first sync hasn't run yet. This sync
57
 * adapter assumes data exists in the provider once a sync has run. If your app doesn't work like
58
 * this, you should add a flag that notes if a sync has run, so you can differentiate between "no
59
 * available data" and "no initial sync", and display this in the UI.
60
 *
61
 * <p>The ActionBar displays a "Refresh" button. When the user clicks "Refresh", the sync adapter
62
 * runs immediately. An indeterminate ProgressBar element is displayed, showing that the sync is
63
 * occurring.
64
 */
65
public class EntryListFragment extends ListFragment
66
        implements LoaderManager.LoaderCallbacks<Cursor> {
67
 
68
    private static final String TAG = "EntryListFragment";
69
 
70
    /**
71
     * Cursor adapter for controlling ListView results.
72
     */
73
    private SimpleCursorAdapter mAdapter;
74
 
75
    /**
76
     * Handle to a SyncObserver. The ProgressBar element is visible until the SyncObserver reports
77
     * that the sync is complete.
78
     *
79
     * <p>This allows us to delete our SyncObserver once the application is no longer in the
80
     * foreground.
81
     */
82
    private Object mSyncObserverHandle;
83
 
84
    /**
85
     * Options menu used to populate ActionBar.
86
     */
87
    private Menu mOptionsMenu;
88
 
89
    /**
90
     * Projection for querying the content provider.
91
     */
92
    private static final String[] PROJECTION = new String[]{
93
            FeedContract.Entry._ID,
94
            FeedContract.Entry.COLUMN_NAME_TITLE,
95
            FeedContract.Entry.COLUMN_NAME_LINK,
96
            FeedContract.Entry.COLUMN_NAME_PUBLISHED
97
    };
98
 
99
    // Column indexes. The index of a column in the Cursor is the same as its relative position in
100
    // the projection.
101
    /** Column index for _ID */
102
    private static final int COLUMN_ID = 0;
103
    /** Column index for title */
104
    private static final int COLUMN_TITLE = 1;
105
    /** Column index for link */
106
    private static final int COLUMN_URL_STRING = 2;
107
    /** Column index for published */
108
    private static final int COLUMN_PUBLISHED = 3;
109
 
110
    /**
111
     * List of Cursor columns to read from when preparing an adapter to populate the ListView.
112
     */
113
    private static final String[] FROM_COLUMNS = new String[]{
114
            FeedContract.Entry.COLUMN_NAME_TITLE,
115
            FeedContract.Entry.COLUMN_NAME_PUBLISHED
116
    };
117
 
118
    /**
119
     * List of Views which will be populated by Cursor data.
120
     */
121
    private static final int[] TO_FIELDS = new int[]{
122
            android.R.id.text1,
123
            android.R.id.text2};
124
 
125
    /**
126
     * Mandatory empty constructor for the fragment manager to instantiate the
127
     * fragment (e.g. upon screen orientation changes).
128
     */
129
    public EntryListFragment() {}
130
 
131
    @Override
132
    public void onCreate(Bundle savedInstanceState) {
133
        super.onCreate(savedInstanceState);
134
        setHasOptionsMenu(true);
135
    }
136
 
137
    /**
138
     * Create SyncAccount at launch, if needed.
139
     *
140
     * <p>This will create a new account with the system for our application, register our
141
     * {@link SyncService} with it, and establish a sync schedule.
142
     */
143
    @Override
144
    public void onAttach(Activity activity) {
145
        super.onAttach(activity);
146
 
147
        // Create account, if needed
148
        SyncUtils.CreateSyncAccount(activity);
149
    }
150
 
151
    @Override
152
    public void onViewCreated(View view, Bundle savedInstanceState) {
153
        super.onViewCreated(view, savedInstanceState);
154
 
155
        mAdapter = new SimpleCursorAdapter(
156
                getActivity(),       // Current context
157
                android.R.layout.simple_list_item_activated_2,  // Layout for individual rows
158
                null,                // Cursor
159
                FROM_COLUMNS,        // Cursor columns to use
160
                TO_FIELDS,           // Layout fields to use
161
                0                    // No flags
162
        );
163
        mAdapter.setViewBinder(new SimpleCursorAdapter.ViewBinder() {
164
            @Override
165
            public boolean setViewValue(View view, Cursor cursor, int i) {
166
                if (i == COLUMN_PUBLISHED) {
167
                    // Convert timestamp to human-readable date
168
                    Time t = new Time();
169
                    t.set(cursor.getLong(i));
170
                    ((TextView) view).setText(t.format("%Y-%m-%d %H:%M"));
171
                    return true;
172
                } else {
173
                    // Let SimpleCursorAdapter handle other fields automatically
174
                    return false;
175
                }
176
            }
177
        });
178
        setListAdapter(mAdapter);
179
        setEmptyText(getText(R.string.loading));
180
        getLoaderManager().initLoader(0, null, this);
181
    }
182
 
183
    @Override
184
    public void onResume() {
185
        super.onResume();
186
        mSyncStatusObserver.onStatusChanged(0);
187
 
188
        // Watch for sync state changes
189
        final int mask = ContentResolver.SYNC_OBSERVER_TYPE_PENDING |
190
                ContentResolver.SYNC_OBSERVER_TYPE_ACTIVE;
191
        mSyncObserverHandle = ContentResolver.addStatusChangeListener(mask, mSyncStatusObserver);
192
    }
193
 
194
    @Override
195
    public void onPause() {
196
        super.onPause();
197
        if (mSyncObserverHandle != null) {
198
            ContentResolver.removeStatusChangeListener(mSyncObserverHandle);
199
            mSyncObserverHandle = null;
200
        }
201
    }
202
 
203
    /**
204
     * Query the content provider for data.
205
     *
206
     * <p>Loaders do queries in a background thread. They also provide a ContentObserver that is
207
     * triggered when data in the content provider changes. When the sync adapter updates the
208
     * content provider, the ContentObserver responds by resetting the loader and then reloading
209
     * it.
210
     */
211
    @Override
212
    public Loader<Cursor> onCreateLoader(int i, Bundle bundle) {
213
        // We only have one loader, so we can ignore the value of i.
214
        // (It'll be '0', as set in onCreate().)
215
        return new CursorLoader(getActivity(),  // Context
216
                FeedContract.Entry.CONTENT_URI, // URI
217
                PROJECTION,                // Projection
218
                null,                           // Selection
219
                null,                           // Selection args
220
                FeedContract.Entry.COLUMN_NAME_PUBLISHED + " desc"); // Sort
221
    }
222
 
223
    /**
224
     * Move the Cursor returned by the query into the ListView adapter. This refreshes the existing
225
     * UI with the data in the Cursor.
226
     */
227
    @Override
228
    public void onLoadFinished(Loader<Cursor> cursorLoader, Cursor cursor) {
229
        mAdapter.changeCursor(cursor);
230
    }
231
 
232
    /**
233
     * Called when the ContentObserver defined for the content provider detects that data has
234
     * changed. The ContentObserver resets the loader, and then re-runs the loader. In the adapter,
235
     * set the Cursor value to null. This removes the reference to the Cursor, allowing it to be
236
     * garbage-collected.
237
     */
238
    @Override
239
    public void onLoaderReset(Loader<Cursor> cursorLoader) {
240
        mAdapter.changeCursor(null);
241
    }
242
 
243
    /**
244
     * Create the ActionBar.
245
     */
246
    @Override
247
    public void onCreateOptionsMenu(Menu menu, MenuInflater inflater) {
248
        super.onCreateOptionsMenu(menu, inflater);
249
        mOptionsMenu = menu;
250
        inflater.inflate(R.menu.main, menu);
251
    }
252
 
253
    /**
254
     * Respond to user gestures on the ActionBar.
255
     */
256
    @Override
257
    public boolean onOptionsItemSelected(MenuItem item) {
258
        switch (item.getItemId()) {
259
            // If the user clicks the "Refresh" button.
260
            case R.id.menu_refresh:
261
                SyncUtils.TriggerRefresh();
262
                return true;
263
        }
264
        return super.onOptionsItemSelected(item);
265
    }
266
 
267
    /**
268
     * Load an article in the default browser when selected by the user.
269
     */
270
    @Override
271
    public void onListItemClick(ListView listView, View view, int position, long id) {
272
        super.onListItemClick(listView, view, position, id);
273
 
274
        // Get a URI for the selected item, then start an Activity that displays the URI. Any
275
        // Activity that filters for ACTION_VIEW and a URI can accept this. In most cases, this will
276
        // be a browser.
277
 
278
        // Get the item at the selected position, in the form of a Cursor.
279
        Cursor c = (Cursor) mAdapter.getItem(position);
280
        // Get the link to the article represented by the item.
281
        String articleUrlString = c.getString(COLUMN_URL_STRING);
282
        if (articleUrlString == null) {
283
            Log.e(TAG, "Attempt to launch entry with null link");
284
            return;
285
        }
286
 
287
        Log.i(TAG, "Opening URL: " + articleUrlString);
288
        // Get a Uri object for the URL string
289
        Uri articleURL = Uri.parse(articleUrlString);
290
        Intent i = new Intent(Intent.ACTION_VIEW, articleURL);
291
        startActivity(i);
292
    }
293
 
294
    /**
295
     * Set the state of the Refresh button. If a sync is active, turn on the ProgressBar widget.
296
     * Otherwise, turn it off.
297
     *
298
     * @param refreshing True if an active sync is occuring, false otherwise
299
     */
300
    @TargetApi(Build.VERSION_CODES.HONEYCOMB)
301
    public void setRefreshActionButtonState(boolean refreshing) {
302
        if (mOptionsMenu == null || Build.VERSION.SDK_INT < Build.VERSION_CODES.HONEYCOMB) {
303
            return;
304
        }
305
 
306
        final MenuItem refreshItem = mOptionsMenu.findItem(R.id.menu_refresh);
307
        if (refreshItem != null) {
308
            if (refreshing) {
309
                refreshItem.setActionView(R.layout.actionbar_indeterminate_progress);
310
            } else {
311
                refreshItem.setActionView(null);
312
            }
313
        }
314
    }
315
 
316
    /**
317
     * Crfate a new anonymous SyncStatusObserver. It's attached to the app's ContentResolver in
318
     * onResume(), and removed in onPause(). If status changes, it sets the state of the Refresh
319
     * button. If a sync is active or pending, the Refresh button is replaced by an indeterminate
320
     * ProgressBar; otherwise, the button itself is displayed.
321
     */
322
    private SyncStatusObserver mSyncStatusObserver = new SyncStatusObserver() {
323
        /** Callback invoked with the sync adapter status changes. */
324
        @Override
325
        public void onStatusChanged(int which) {
326
            getActivity().runOnUiThread(new Runnable() {
327
                /**
328
                 * The SyncAdapter runs on a background thread. To update the UI, onStatusChanged()
329
                 * runs on the UI thread.
330
                 */
331
                @Override
332
                public void run() {
333
                    // Create a handle to the account that was created by
334
                    // SyncService.CreateSyncAccount(). This will be used to query the system to
335
                    // see how the sync status has changed.
336
                    Account account = GenericAccountService.GetAccount(SyncUtils.ACCOUNT_TYPE);
337
                    if (account == null) {
338
                        // GetAccount() returned an invalid value. This shouldn't happen, but
339
                        // we'll set the status to "not refreshing".
340
                        setRefreshActionButtonState(false);
341
                        return;
342
                    }
343
 
344
                    // Test the ContentResolver to see if the sync adapter is active or pending.
345
                    // Set the state of the refresh button accordingly.
346
                    boolean syncActive = ContentResolver.isSyncActive(
347
                            account, FeedContract.CONTENT_AUTHORITY);
348
                    boolean syncPending = ContentResolver.isSyncPending(
349
                            account, FeedContract.CONTENT_AUTHORITY);
350
                    setRefreshActionButtonState(syncActive || syncPending);
351
                }
352
            });
353
        }
354
    };
355
 
356
}