am 2c063c88: Android Training: Threads sample app
* commit '2c063c889aa816e0de91bf17fdc0c78f48d5e2d0':
Android Training: Threads sample app
diff --git a/samples/training/threadsample/AndroidManifest.xml b/samples/training/threadsample/AndroidManifest.xml
new file mode 100644
index 0000000..7b39207
--- /dev/null
+++ b/samples/training/threadsample/AndroidManifest.xml
@@ -0,0 +1,66 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+ * Copyright (C) 2012 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+-->
+<manifest xmlns:android="http://schemas.android.com/apk/res/android"
+ package="com.example.android.threadsample"
+ android:versionCode="1"
+ android:versionName="1.0" >
+
+ <uses-sdk
+ android:minSdkVersion="11"
+ android:targetSdkVersion="17" />
+
+ <!-- Requires this permission to download RSS data from Picasa -->
+ <uses-permission android:name="android.permission.INTERNET" />
+
+ <!-- Requires this permission to check the network state -->
+ <uses-permission android:name="android.permission.ACCESS_NETWORK_STATE"/>
+
+ <!--
+ Defines the application.
+ -->
+ <application
+ android:icon="@drawable/icon"
+ android:label="@string/app_name">
+
+ <activity
+ android:name=".DisplayActivity"
+ android:label="@string/activity_title" >
+ <intent-filter>
+ <action android:name="android.intent.action.MAIN" />
+ <category android:name="android.intent.category.LAUNCHER" />
+ </intent-filter>
+ </activity>
+
+ <!--
+ No intent filters are specified, so android:exported defaults to "false". The
+ service is only available to this app.
+ -->
+ <service
+ android:name=".RSSPullService"
+ android:exported="false"/>
+
+ <!--
+ The attribute "android:exported" must be set to "false" to restrict this content
+ provider to its own app. Otherwise, all apps could access it.
+ -->
+ <provider
+ android:name=".DataProvider"
+ android:exported="false"
+ android:authorities="@string/authority"/>
+ </application>
+
+</manifest>
diff --git a/samples/training/threadsample/res/drawable-hdpi/icon.png b/samples/training/threadsample/res/drawable-hdpi/icon.png
new file mode 100644
index 0000000..bf461aa
--- /dev/null
+++ b/samples/training/threadsample/res/drawable-hdpi/icon.png
Binary files differ
diff --git a/samples/training/threadsample/res/drawable-ldpi/icon.png b/samples/training/threadsample/res/drawable-ldpi/icon.png
new file mode 100644
index 0000000..e80fe01
--- /dev/null
+++ b/samples/training/threadsample/res/drawable-ldpi/icon.png
Binary files differ
diff --git a/samples/training/threadsample/res/drawable-mdpi/icon.png b/samples/training/threadsample/res/drawable-mdpi/icon.png
new file mode 100644
index 0000000..ba7a853
--- /dev/null
+++ b/samples/training/threadsample/res/drawable-mdpi/icon.png
Binary files differ
diff --git a/samples/training/threadsample/res/drawable-xhdpi/icon.png b/samples/training/threadsample/res/drawable-xhdpi/icon.png
new file mode 100644
index 0000000..72c2b27
--- /dev/null
+++ b/samples/training/threadsample/res/drawable-xhdpi/icon.png
Binary files differ
diff --git a/samples/training/threadsample/res/drawable/decodedecoding.xml b/samples/training/threadsample/res/drawable/decodedecoding.xml
new file mode 100644
index 0000000..0133903
--- /dev/null
+++ b/samples/training/threadsample/res/drawable/decodedecoding.xml
@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="utf-8"?>
+<shape android:shape="rectangle"
+ xmlns:android="http://schemas.android.com/apk/res/android">
+ <!-- orange -->
+ <solid android:color="#fff8ef66" />
+</shape>
diff --git a/samples/training/threadsample/res/drawable/decodequeued.xml b/samples/training/threadsample/res/drawable/decodequeued.xml
new file mode 100644
index 0000000..fdbbe1a
--- /dev/null
+++ b/samples/training/threadsample/res/drawable/decodequeued.xml
@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="utf-8"?>
+<shape android:shape="rectangle"
+ xmlns:android="http://schemas.android.com/apk/res/android">
+ <!-- golden yellow -->
+ <solid android:color="#ffaca865" />
+</shape>
diff --git a/samples/training/threadsample/res/drawable/imagedownloadfailed.xml b/samples/training/threadsample/res/drawable/imagedownloadfailed.xml
new file mode 100644
index 0000000..ca1d72f
--- /dev/null
+++ b/samples/training/threadsample/res/drawable/imagedownloadfailed.xml
@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="utf-8"?>
+<shape android:shape="rectangle"
+ xmlns:android="http://schemas.android.com/apk/res/android">
+ <!-- dark red -->
+ <solid android:color="#ffbf1111" />
+</shape>
diff --git a/samples/training/threadsample/res/drawable/imagedownloading.xml b/samples/training/threadsample/res/drawable/imagedownloading.xml
new file mode 100644
index 0000000..46a707e
--- /dev/null
+++ b/samples/training/threadsample/res/drawable/imagedownloading.xml
@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="utf-8"?>
+<shape android:shape="rectangle"
+ xmlns:android="http://schemas.android.com/apk/res/android">
+ <!-- dark green opaque -->
+ <solid android:color="#ff2a6a22" />
+</shape>
diff --git a/samples/training/threadsample/res/drawable/imagenotqueued.xml b/samples/training/threadsample/res/drawable/imagenotqueued.xml
new file mode 100644
index 0000000..ea2eec5
--- /dev/null
+++ b/samples/training/threadsample/res/drawable/imagenotqueued.xml
@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="utf-8"?>
+<shape android:shape="rectangle"
+ xmlns:android="http://schemas.android.com/apk/res/android">
+ <!-- opaque near black -->
+ <solid android:color="#ff444444" />
+</shape>
diff --git a/samples/training/threadsample/res/drawable/imagequeued.xml b/samples/training/threadsample/res/drawable/imagequeued.xml
new file mode 100644
index 0000000..f1342b8
--- /dev/null
+++ b/samples/training/threadsample/res/drawable/imagequeued.xml
@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="utf-8"?>
+<shape android:shape="rectangle"
+ xmlns:android="http://schemas.android.com/apk/res/android">
+ <solid android:color="#ff888888" />
+</shape>
diff --git a/samples/training/threadsample/res/layout/fragmenthost.xml b/samples/training/threadsample/res/layout/fragmenthost.xml
new file mode 100644
index 0000000..39e72f1
--- /dev/null
+++ b/samples/training/threadsample/res/layout/fragmenthost.xml
@@ -0,0 +1,24 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+/*
+ * Copyright (C) 2012 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+-->
+<LinearLayout
+ android:orientation="horizontal"
+ android:id="@+id/fragmentHost"
+ android:layout_width="fill_parent" android:layout_height="fill_parent"
+ android:animateLayoutChanges="true"
+ xmlns:android="http://schemas.android.com/apk/res/android" />
diff --git a/samples/training/threadsample/res/layout/galleryitem.xml b/samples/training/threadsample/res/layout/galleryitem.xml
new file mode 100644
index 0000000..187ba77
--- /dev/null
+++ b/samples/training/threadsample/res/layout/galleryitem.xml
@@ -0,0 +1,30 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+/*
+ * Copyright (C) 2012 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+-->
+<!-- Defines a single thumbnail view -->
+<FrameLayout
+ android:layout_width="?android:listPreferredItemHeight"
+ android:layout_height="?android:listPreferredItemHeight"
+ xmlns:android="http://schemas.android.com/apk/res/android">
+ <com.example.android.threadsample.PhotoView
+ android:id="@+id/thumbImage"
+ android:layout_width="fill_parent"
+ android:layout_height="fill_parent"
+ android:scaleType="centerCrop"
+ android:adjustViewBounds="true" />
+</FrameLayout>
diff --git a/samples/training/threadsample/res/layout/gridlist.xml b/samples/training/threadsample/res/layout/gridlist.xml
new file mode 100644
index 0000000..df07423
--- /dev/null
+++ b/samples/training/threadsample/res/layout/gridlist.xml
@@ -0,0 +1,42 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+/*
+ * Copyright (C) 2012 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+-->
+<FrameLayout
+ xmlns:android="http://schemas.android.com/apk/res/android"
+ android:layout_gravity="center"
+ android:layout_width="0.0dip"
+ android:layout_height="fill_parent"
+ android:layout_weight="1.0">
+ <GridView
+ android:id="@android:id/list"
+ android:alwaysDrawnWithCache="true"
+ android:layout_width="fill_parent"
+ android:layout_height="wrap_content"
+ android:cacheColorHint="@android:color/black"/>
+ <LinearLayout
+ xmlns:android="http://schemas.android.com/apk/res/android"
+ android:id="@+id/progressRoot"
+ android:gravity="center"
+ android:visibility="invisible"
+ android:layout_width="fill_parent"
+ android:layout_height="fill_parent">
+<ProgressBar android:layout_gravity="center_vertical"
+ android:paddingLeft="10.0dip" android:layout_width="wrap_content"
+ android:layout_height="wrap_content" />
+ </LinearLayout>
+</FrameLayout>
diff --git a/samples/training/threadsample/res/layout/photo.xml b/samples/training/threadsample/res/layout/photo.xml
new file mode 100644
index 0000000..93b5ca6
--- /dev/null
+++ b/samples/training/threadsample/res/layout/photo.xml
@@ -0,0 +1,32 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+/*
+ * Copyright (C) 2012 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+-->
+<!-- Defines a single full-screen image -->
+<FrameLayout
+ android:layout_width="0.0dip"
+ android:layout_height="fill_parent"
+ android:layout_weight="3.0"
+ xmlns:android="http://schemas.android.com/apk/res/android"
+ xmlns:image="http://schemas.android.com/apk/res/com.example.android.threadsample">
+ <ProgressBar android:layout_gravity="center" android:id="@+id/photoProgress"
+ android:layout_width="wrap_content" android:layout_height="wrap_content" />
+ <com.example.android.threadsample.PhotoView
+ android:id="@+id/photoView" android:layout_width="fill_parent"
+ android:layout_height="fill_parent" android:scaleType="centerInside"
+ image:hideShowSibling="@id/photoProgress" />
+</FrameLayout>
diff --git a/samples/training/threadsample/res/layout/progress.xml b/samples/training/threadsample/res/layout/progress.xml
new file mode 100644
index 0000000..12ff0ed
--- /dev/null
+++ b/samples/training/threadsample/res/layout/progress.xml
@@ -0,0 +1,37 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+ * Copyright (C) 2012 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+-->
+<!--
+ Defines the layout that shows the progress of downloading and parsing the RSS fead.
+ -->
+<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
+ android:id="@+id/progressRoot"
+ android:layout_width="match_parent"
+ android:layout_height="match_parent">
+
+
+ <!-- Shows an activity indicator -->
+
+ <ProgressBar
+ android:id="@+id/Progress"
+ style="@android:style/Widget.ProgressBar.Large"
+ android:layout_width="wrap_content"
+ android:layout_height="wrap_content"
+ android:layout_centerInParent="true"
+ android:indeterminateOnly="true"
+ android:visibility="visible"/>
+
+</RelativeLayout>
diff --git a/samples/training/threadsample/res/values-sw600dp/bools.xml b/samples/training/threadsample/res/values-sw600dp/bools.xml
new file mode 100644
index 0000000..ccba3a5
--- /dev/null
+++ b/samples/training/threadsample/res/values-sw600dp/bools.xml
@@ -0,0 +1,7 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!-- The reason this is done is that on ICS tablets (>= sw600) , hiding the navigation has no function, but
+causes the side effect of eating a tap that would otherwise be delivered to the framework. -->
+<resources>
+ <bool name="sideBySide">true</bool>
+ <bool name="hideNavigation">false</bool>
+</resources>
\ No newline at end of file
diff --git a/samples/training/threadsample/res/values-sw600dp/dimens.xml b/samples/training/threadsample/res/values-sw600dp/dimens.xml
new file mode 100644
index 0000000..c3fe548
--- /dev/null
+++ b/samples/training/threadsample/res/values-sw600dp/dimens.xml
@@ -0,0 +1,4 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources>
+ <dimen name="thumbSize">160.0dip</dimen>
+</resources>
diff --git a/samples/training/threadsample/res/values-v11/styles.xml b/samples/training/threadsample/res/values-v11/styles.xml
new file mode 100644
index 0000000..6f91b36
--- /dev/null
+++ b/samples/training/threadsample/res/values-v11/styles.xml
@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources>
+ <style name="Theme.NoBackground" parent="@android:style/Theme.Holo">
+ <item name="android:windowBackground">@android:color/black</item>
+ </style>
+</resources>
\ No newline at end of file
diff --git a/samples/training/threadsample/res/values-xlarge/bools.xml b/samples/training/threadsample/res/values-xlarge/bools.xml
new file mode 100644
index 0000000..ccba3a5
--- /dev/null
+++ b/samples/training/threadsample/res/values-xlarge/bools.xml
@@ -0,0 +1,7 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!-- The reason this is done is that on ICS tablets (>= sw600) , hiding the navigation has no function, but
+causes the side effect of eating a tap that would otherwise be delivered to the framework. -->
+<resources>
+ <bool name="sideBySide">true</bool>
+ <bool name="hideNavigation">false</bool>
+</resources>
\ No newline at end of file
diff --git a/samples/training/threadsample/res/values-xlarge/dimens.xml b/samples/training/threadsample/res/values-xlarge/dimens.xml
new file mode 100644
index 0000000..c3fe548
--- /dev/null
+++ b/samples/training/threadsample/res/values-xlarge/dimens.xml
@@ -0,0 +1,4 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources>
+ <dimen name="thumbSize">160.0dip</dimen>
+</resources>
diff --git a/samples/training/threadsample/res/values/attrs.xml b/samples/training/threadsample/res/values/attrs.xml
new file mode 100644
index 0000000..b987298
--- /dev/null
+++ b/samples/training/threadsample/res/values/attrs.xml
@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources>
+ <declare-styleable name="ImageDownloaderView">
+ <!-- The sibling to hide after the image is downloaded
+ and show when the image is being downloaded -->
+ <attr format="reference" name="hideShowSibling" />
+ </declare-styleable>
+</resources>
\ No newline at end of file
diff --git a/samples/training/threadsample/res/values/bools.xml b/samples/training/threadsample/res/values/bools.xml
new file mode 100644
index 0000000..6a944d7
--- /dev/null
+++ b/samples/training/threadsample/res/values/bools.xml
@@ -0,0 +1,9 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+ The reason this is done is that on tablets (>= sw600) , hiding the navigation has no function,
+ but causes the side effect of eating a tap that would otherwise be delivered to the framework.
+-->
+<resources>
+ <bool name="sideBySide">false</bool>
+ <bool name="hideNavigation">true</bool>
+</resources>
diff --git a/samples/training/threadsample/res/values/dimens.xml b/samples/training/threadsample/res/values/dimens.xml
new file mode 100644
index 0000000..c3fe548
--- /dev/null
+++ b/samples/training/threadsample/res/values/dimens.xml
@@ -0,0 +1,4 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources>
+ <dimen name="thumbSize">160.0dip</dimen>
+</resources>
diff --git a/samples/training/threadsample/res/values/strings.xml b/samples/training/threadsample/res/values/strings.xml
new file mode 100644
index 0000000..81d9035
--- /dev/null
+++ b/samples/training/threadsample/res/values/strings.xml
@@ -0,0 +1,13 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources>
+ <string name="authority">com.example.android.threadsample</string>
+ <string name="app_name">Picasa Images</string>
+ <string name="activity_title">Picasa Images</string>
+ <string name="progress_starting_update">Starting Update</string>
+ <string name="progress_connecting">Connecting</string>
+ <string name="progress_parsing">Parsing</string>
+ <string name="progress_writing">Writing to Database</string>
+ <string name="no_connection">In offline mode, and no stored data is available.</string>
+ <string name="alert_description">Alert!</string>
+ <string name="offline_mode">In offline mode. Stored data is shown.</string>
+</resources>
diff --git a/samples/training/threadsample/res/values/styles.xml b/samples/training/threadsample/res/values/styles.xml
new file mode 100644
index 0000000..d293831
--- /dev/null
+++ b/samples/training/threadsample/res/values/styles.xml
@@ -0,0 +1,24 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+ * Copyright (C) 2012 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+-->
+<!--
+ Defines a style resource for a black background
+ -->
+<resources>
+ <style name="Theme.NoBackground" parent="@android:style/Theme.NoTitleBar">
+ <item name="android:windowBackground">@android:color/black</item>
+ </style>
+</resources>
diff --git a/samples/training/threadsample/src/com/example/android/threadsample/BroadcastNotifier.java b/samples/training/threadsample/src/com/example/android/threadsample/BroadcastNotifier.java
new file mode 100644
index 0000000..120f6e0
--- /dev/null
+++ b/samples/training/threadsample/src/com/example/android/threadsample/BroadcastNotifier.java
@@ -0,0 +1,87 @@
+/*
+ * Copyright (C) 2012 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.example.android.threadsample;
+
+import android.content.Context;
+import android.content.Intent;
+import android.support.v4.content.LocalBroadcastManager;
+
+public class BroadcastNotifier {
+
+ private LocalBroadcastManager mBroadcaster;
+
+ /**
+ * Creates a BroadcastNotifier containing an instance of LocalBroadcastManager.
+ * LocalBroadcastManager is more efficient than BroadcastManager; because it only
+ * broadcasts to components within the app, it doesn't have to do parceling and so forth.
+ *
+ * @param context a Context from which to get the LocalBroadcastManager
+ */
+ public BroadcastNotifier(Context context) {
+
+ // Gets an instance of the support library local broadcastmanager
+ mBroadcaster = LocalBroadcastManager.getInstance(context);
+
+ }
+
+ /**
+ *
+ * Uses LocalBroadcastManager to send an {@link Intent} containing {@code status}. The
+ * {@link Intent} has the action {@code BROADCAST_ACTION} and the category {@code DEFAULT}.
+ *
+ * @param status {@link Integer} denoting a work request status
+ */
+ public void broadcastIntentWithState(int status) {
+
+ Intent localIntent = new Intent();
+
+ // The Intent contains the custom broadcast action for this app
+ localIntent.setAction(Constants.BROADCAST_ACTION);
+
+ // Puts the status into the Intent
+ localIntent.putExtra(Constants.EXTENDED_DATA_STATUS, status);
+ localIntent.addCategory(Intent.CATEGORY_DEFAULT);
+
+ // Broadcasts the Intent
+ mBroadcaster.sendBroadcast(localIntent);
+
+ }
+
+ /**
+ * Uses LocalBroadcastManager to send an {@link String} containing a logcat message.
+ * {@link Intent} has the action {@code BROADCAST_ACTION} and the category {@code DEFAULT}.
+ *
+ * @param logData a {@link String} to insert into the log.
+ */
+ public void notifyProgress(String logData) {
+
+ Intent localIntent = new Intent();
+
+ // The Intent contains the custom broadcast action for this app
+ localIntent.setAction(Constants.BROADCAST_ACTION);
+
+ localIntent.putExtra(Constants.EXTENDED_DATA_STATUS, -1);
+
+ // Puts log data into the Intent
+ localIntent.putExtra(Constants.EXTENDED_STATUS_LOG, logData);
+ localIntent.addCategory(Intent.CATEGORY_DEFAULT);
+
+ // Broadcasts the Intent
+ mBroadcaster.sendBroadcast(localIntent);
+
+ }
+}
diff --git a/samples/training/threadsample/src/com/example/android/threadsample/Constants.java b/samples/training/threadsample/src/com/example/android/threadsample/Constants.java
new file mode 100644
index 0000000..0d8909f
--- /dev/null
+++ b/samples/training/threadsample/src/com/example/android/threadsample/Constants.java
@@ -0,0 +1,91 @@
+/*
+ * Copyright (C) 2012 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.example.android.threadsample;
+
+import java.util.Locale;
+
+/**
+ *
+ * Constants used by multiple classes in this package
+ */
+public final class Constants {
+
+ // Set to true to turn on verbose logging
+ public static final boolean LOGV = false;
+
+ // Set to true to turn on debug logging
+ public static final boolean LOGD = true;
+
+ // Custom actions
+
+ public static final String ACTION_VIEW_IMAGE =
+ "com.example.android.threadsample.ACTION_VIEW_IMAGE";
+
+ public static final String ACTION_ZOOM_IMAGE =
+ "com.example.android.threadsample.ACTION_ZOOM_IMAGE";
+
+ // Defines a custom Intent action
+ public static final String BROADCAST_ACTION = "com.example.android.threadsample.BROADCAST";
+
+ // Fragment tags
+ public static final String PHOTO_FRAGMENT_TAG =
+ "com.example.android.threadsample.PHOTO_FRAGMENT_TAG";
+
+ public static final String THUMBNAIL_FRAGMENT_TAG =
+ "com.example.android.threadsample.THUMBNAIL_FRAGMENT_TAG";
+
+ // Defines the key for the status "extra" in an Intent
+ public static final String EXTENDED_DATA_STATUS = "com.example.android.threadsample.STATUS";
+
+ // Defines the key for the log "extra" in an Intent
+ public static final String EXTENDED_STATUS_LOG = "com.example.android.threadsample.LOG";
+
+ // Defines the key for storing fullscreen state
+ public static final String EXTENDED_FULLSCREEN =
+ "com.example.android.threadsample.EXTENDED_FULLSCREEN";
+
+ /*
+ * A user-agent string that's sent to the HTTP site. It includes information about the device
+ * and the build that the device is running.
+ */
+ public static final String USER_AGENT = "Mozilla/5.0 (Linux; U; Android "
+ + android.os.Build.VERSION.RELEASE + ";"
+ + Locale.getDefault().toString() + "; " + android.os.Build.DEVICE
+ + "/" + android.os.Build.ID + ")";
+
+ // Status values to broadcast to the Activity
+
+ // The download is starting
+ public static final int STATE_ACTION_STARTED = 0;
+
+ // The background thread is connecting to the RSS feed
+ public static final int STATE_ACTION_CONNECTING = 1;
+
+ // The background thread is parsing the RSS feed
+ public static final int STATE_ACTION_PARSING = 2;
+
+ // The background thread is writing data to the content provider
+ public static final int STATE_ACTION_WRITING = 3;
+
+ // The background thread is done
+ public static final int STATE_ACTION_COMPLETE = 4;
+
+ // The background thread is doing logging
+ public static final int STATE_LOG = -1;
+
+ public static final CharSequence BLANK = " ";
+}
diff --git a/samples/training/threadsample/src/com/example/android/threadsample/DataProvider.java b/samples/training/threadsample/src/com/example/android/threadsample/DataProvider.java
new file mode 100644
index 0000000..3741fec
--- /dev/null
+++ b/samples/training/threadsample/src/com/example/android/threadsample/DataProvider.java
@@ -0,0 +1,482 @@
+/*
+ * Copyright (C) 2012 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.example.android.threadsample;
+
+import android.content.ContentProvider;
+import android.content.ContentValues;
+import android.content.Context;
+import android.content.UriMatcher;
+import android.database.Cursor;
+import android.database.sqlite.SQLiteDatabase;
+import android.database.sqlite.SQLiteException;
+import android.database.sqlite.SQLiteOpenHelper;
+import android.net.Uri;
+import android.util.Log;
+import android.util.SparseArray;
+
+/**
+ *
+ * Defines a ContentProvider that stores URLs of Picasa featured pictures
+ * The provider also has a table that tracks the last time a picture URL was updated.
+ */
+public class DataProvider extends ContentProvider {
+ // Indicates that the incoming query is for a picture URL
+ public static final int IMAGE_URL_QUERY = 1;
+
+ // Indicates that the incoming query is for a URL modification date
+ public static final int URL_DATE_QUERY = 2;
+
+ // Indicates an invalid content URI
+ public static final int INVALID_URI = -1;
+
+ // Constants for building SQLite tables during initialization
+ private static final String TEXT_TYPE = "TEXT";
+ private static final String PRIMARY_KEY_TYPE = "INTEGER PRIMARY KEY";
+ private static final String INTEGER_TYPE = "INTEGER";
+
+ // Defines an SQLite statement that builds the Picasa picture URL table
+ private static final String CREATE_PICTUREURL_TABLE_SQL = "CREATE TABLE" + " " +
+ DataProviderContract.PICTUREURL_TABLE_NAME + " " +
+ "(" + " " +
+ DataProviderContract.ROW_ID + " " + PRIMARY_KEY_TYPE + " ," +
+ DataProviderContract.IMAGE_THUMBURL_COLUMN + " " + TEXT_TYPE + " ," +
+ DataProviderContract.IMAGE_URL_COLUMN + " " + TEXT_TYPE + " ," +
+ DataProviderContract.IMAGE_THUMBNAME_COLUMN + " " + TEXT_TYPE + " ," +
+ DataProviderContract.IMAGE_PICTURENAME_COLUMN + " " + TEXT_TYPE +
+ ")";
+
+ // Defines an SQLite statement that builds the URL modification date table
+ private static final String CREATE_DATE_TABLE_SQL = "CREATE TABLE" + " " +
+ DataProviderContract.DATE_TABLE_NAME + " " +
+ "(" + " " +
+ DataProviderContract.ROW_ID + " " + PRIMARY_KEY_TYPE + " ," +
+ DataProviderContract.DATA_DATE_COLUMN + " " + INTEGER_TYPE +
+ ")";
+
+ // Identifies log statements issued by this component
+ public static final String LOG_TAG = "DataProvider";
+
+ // Defines an helper object for the backing database
+ private SQLiteOpenHelper mHelper;
+
+ // Defines a helper object that matches content URIs to table-specific parameters
+ private static final UriMatcher sUriMatcher;
+
+ // Stores the MIME types served by this provider
+ private static final SparseArray<String> sMimeTypes;
+
+ /*
+ * Initializes meta-data used by the content provider:
+ * - UriMatcher that maps content URIs to codes
+ * - MimeType array that returns the custom MIME type of a table
+ */
+ static {
+
+ // Creates an object that associates content URIs with numeric codes
+ sUriMatcher = new UriMatcher(0);
+
+ /*
+ * Sets up an array that maps content URIs to MIME types, via a mapping between the
+ * URIs and an integer code. These are custom MIME types that apply to tables and rows
+ * in this particular provider.
+ */
+ sMimeTypes = new SparseArray<String>();
+
+ // Adds a URI "match" entry that maps picture URL content URIs to a numeric code
+ sUriMatcher.addURI(
+ DataProviderContract.AUTHORITY,
+ DataProviderContract.PICTUREURL_TABLE_NAME,
+ IMAGE_URL_QUERY);
+
+ // Adds a URI "match" entry that maps modification date content URIs to a numeric code
+ sUriMatcher.addURI(
+ DataProviderContract.AUTHORITY,
+ DataProviderContract.DATE_TABLE_NAME,
+ URL_DATE_QUERY);
+
+ // Specifies a custom MIME type for the picture URL table
+ sMimeTypes.put(
+ IMAGE_URL_QUERY,
+ "vnd.android.cursor.dir/vnd." +
+ DataProviderContract.AUTHORITY + "." +
+ DataProviderContract.PICTUREURL_TABLE_NAME);
+
+ // Specifies the custom MIME type for a single modification date row
+ sMimeTypes.put(
+ URL_DATE_QUERY,
+ "vnd.android.cursor.item/vnd."+
+ DataProviderContract.AUTHORITY + "." +
+ DataProviderContract.DATE_TABLE_NAME);
+ }
+
+ // Closes the SQLite database helper class, to avoid memory leaks
+ public void close() {
+ mHelper.close();
+ }
+
+ /**
+ * Defines a helper class that opens the SQLite database for this provider when a request is
+ * received. If the database doesn't yet exist, the helper creates it.
+ */
+ private class DataProviderHelper extends SQLiteOpenHelper {
+ /**
+ * Instantiates a new SQLite database using the supplied database name and version
+ *
+ * @param context The current context
+ */
+ DataProviderHelper(Context context) {
+ super(context,
+ DataProviderContract.DATABASE_NAME,
+ null,
+ DataProviderContract.DATABASE_VERSION);
+ }
+
+
+ /**
+ * Executes the queries to drop all of the tables from the database.
+ *
+ * @param db A handle to the provider's backing database.
+ */
+ private void dropTables(SQLiteDatabase db) {
+
+ // If the table doesn't exist, don't throw an error
+ db.execSQL("DROP TABLE IF EXISTS " + DataProviderContract.PICTUREURL_TABLE_NAME);
+ db.execSQL("DROP TABLE IF EXISTS " + DataProviderContract.DATE_TABLE_NAME);
+ }
+
+ /**
+ * Does setup of the database. The system automatically invokes this method when
+ * SQLiteDatabase.getWriteableDatabase() or SQLiteDatabase.getReadableDatabase() are
+ * invoked and no db instance is available.
+ *
+ * @param db the database instance in which to create the tables.
+ */
+ @Override
+ public void onCreate(SQLiteDatabase db) {
+ // Creates the tables in the backing database for this provider
+ db.execSQL(CREATE_PICTUREURL_TABLE_SQL);
+ db.execSQL(CREATE_DATE_TABLE_SQL);
+
+ }
+
+ /**
+ * Handles upgrading the database from a previous version. Drops the old tables and creates
+ * new ones.
+ *
+ * @param db The database to upgrade
+ * @param version1 The old database version
+ * @param version2 The new database version
+ */
+ @Override
+ public void onUpgrade(SQLiteDatabase db, int version1, int version2) {
+ Log.w(DataProviderHelper.class.getName(),
+ "Upgrading database from version " + version1 + " to "
+ + version2 + ", which will destroy all the existing data");
+
+ // Drops all the existing tables in the database
+ dropTables(db);
+
+ // Invokes the onCreate callback to build new tables
+ onCreate(db);
+ }
+ /**
+ * Handles downgrading the database from a new to a previous version. Drops the old tables
+ * and creates new ones.
+ * @param db The database object to downgrade
+ * @param version1 The old database version
+ * @param version2 The new database version
+ */
+ @Override
+ public void onDowngrade(SQLiteDatabase db, int version1, int version2) {
+ Log.w(DataProviderHelper.class.getName(),
+ "Downgrading database from version " + version1 + " to "
+ + version2 + ", which will destroy all the existing data");
+
+ // Drops all the existing tables in the database
+ dropTables(db);
+
+ // Invokes the onCreate callback to build new tables
+ onCreate(db);
+
+ }
+ }
+ /**
+ * Initializes the content provider. Notice that this method simply creates a
+ * the SQLiteOpenHelper instance and returns. You should do most of the initialization of a
+ * content provider in its static initialization block or in SQLiteDatabase.onCreate().
+ */
+ @Override
+ public boolean onCreate() {
+
+ // Creates a new database helper object
+ mHelper = new DataProviderHelper(getContext());
+
+ return true;
+ }
+ /**
+ * Returns the result of querying the chosen table.
+ * @see android.content.ContentProvider#query(Uri, String[], String, String[], String)
+ * @param uri The content URI of the table
+ * @param projection The names of the columns to return in the cursor
+ * @param selection The selection clause for the query
+ * @param selectionArgs An array of Strings containing search criteria
+ * @param sortOrder A clause defining the order in which the retrieved rows should be sorted
+ * @return The query results, as a {@link android.database.Cursor} of rows and columns
+ */
+ @Override
+ public Cursor query(
+ Uri uri,
+ String[] projection,
+ String selection,
+ String[] selectionArgs,
+ String sortOrder) {
+
+ SQLiteDatabase db = mHelper.getReadableDatabase();
+ // Decodes the content URI and maps it to a code
+ switch (sUriMatcher.match(uri)) {
+
+ // If the query is for a picture URL
+ case IMAGE_URL_QUERY:
+ // Does the query against a read-only version of the database
+ Cursor returnCursor = db.query(
+ DataProviderContract.PICTUREURL_TABLE_NAME,
+ projection,
+ null, null, null, null, null);
+
+ // Sets the ContentResolver to watch this content URI for data changes
+ returnCursor.setNotificationUri(getContext().getContentResolver(), uri);
+ return returnCursor;
+
+ // If the query is for a modification date URL
+ case URL_DATE_QUERY:
+ returnCursor = db.query(
+ DataProviderContract.DATE_TABLE_NAME,
+ projection,
+ selection,
+ selectionArgs,
+ null,
+ null,
+ sortOrder);
+
+ // No notification Uri is set, because the data doesn't have to be watched.
+ return returnCursor;
+
+ case INVALID_URI:
+
+ throw new IllegalArgumentException("Query -- Invalid URI:" + uri);
+ }
+
+ return null;
+ }
+
+ /**
+ * Returns the mimeType associated with the Uri (query).
+ * @see android.content.ContentProvider#getType(Uri)
+ * @param uri the content URI to be checked
+ * @return the corresponding MIMEtype
+ */
+ @Override
+ public String getType(Uri uri) {
+
+ return sMimeTypes.get(sUriMatcher.match(uri));
+ }
+ /**
+ *
+ * Insert a single row into a table
+ * @see android.content.ContentProvider#insert(Uri, ContentValues)
+ * @param uri the content URI of the table
+ * @param values a {@link android.content.ContentValues} object containing the row to insert
+ * @return the content URI of the new row
+ */
+ @Override
+ public Uri insert(Uri uri, ContentValues values) {
+
+ // Decode the URI to choose which action to take
+ switch (sUriMatcher.match(uri)) {
+
+ // For the modification date table
+ case URL_DATE_QUERY:
+
+ // Creates a writeable database or gets one from cache
+ SQLiteDatabase localSQLiteDatabase = mHelper.getWritableDatabase();
+
+ // Inserts the row into the table and returns the new row's _id value
+ long id = localSQLiteDatabase.insert(
+ DataProviderContract.DATE_TABLE_NAME,
+ DataProviderContract.DATA_DATE_COLUMN,
+ values
+ );
+
+ // If the insert succeeded, notify a change and return the new row's content URI.
+ if (-1 != id) {
+ getContext().getContentResolver().notifyChange(uri, null);
+ return Uri.withAppendedPath(uri, Long.toString(id));
+ } else {
+
+ throw new SQLiteException("Insert error:" + uri);
+ }
+ case IMAGE_URL_QUERY:
+
+ throw new IllegalArgumentException("Insert: Invalid URI" + uri);
+ }
+
+ return null;
+ }
+ /**
+ * Implements bulk row insertion using
+ * {@link SQLiteDatabase#insert(String, String, ContentValues) SQLiteDatabase.insert()}
+ * and SQLite transactions. The method also notifies the current
+ * {@link android.content.ContentResolver} that the {@link android.content.ContentProvider} has
+ * been changed.
+ * @see android.content.ContentProvider#bulkInsert(Uri, ContentValues[])
+ * @param uri The content URI for the insertion
+ * @param insertValuesArray A {@link android.content.ContentValues} array containing the row to
+ * insert
+ * @return The number of rows inserted.
+ */
+ @Override
+ public int bulkInsert(Uri uri, ContentValues[] insertValuesArray) {
+
+ // Decodes the content URI and choose which insert to use
+ switch (sUriMatcher.match(uri)) {
+
+ // picture URLs table
+ case IMAGE_URL_QUERY:
+
+ // Gets a writeable database instance if one is not already cached
+ SQLiteDatabase localSQLiteDatabase = mHelper.getWritableDatabase();
+
+ /*
+ * Begins a transaction in "exclusive" mode. No other mutations can occur on the
+ * db until this transaction finishes.
+ */
+ localSQLiteDatabase.beginTransaction();
+
+ // Deletes all the existing rows in the table
+ localSQLiteDatabase.delete(DataProviderContract.PICTUREURL_TABLE_NAME, null, null);
+
+ // Gets the size of the bulk insert
+ int numImages = insertValuesArray.length;
+
+ // Inserts each ContentValues entry in the array as a row in the database
+ for (int i = 0; i < numImages; i++) {
+
+ localSQLiteDatabase.insert(DataProviderContract.PICTUREURL_TABLE_NAME,
+ DataProviderContract.IMAGE_URL_COLUMN, insertValuesArray[i]);
+ }
+
+ // Reports that the transaction was successful and should not be backed out.
+ localSQLiteDatabase.setTransactionSuccessful();
+
+ // Ends the transaction and closes the current db instances
+ localSQLiteDatabase.endTransaction();
+ localSQLiteDatabase.close();
+
+ /*
+ * Notifies the current ContentResolver that the data associated with "uri" has
+ * changed.
+ */
+
+ getContext().getContentResolver().notifyChange(uri, null);
+
+ // The semantics of bulkInsert is to return the number of rows inserted.
+ return numImages;
+
+ // modification date table
+ case URL_DATE_QUERY:
+
+ // Do inserts by calling SQLiteDatabase.insert on each row in insertValuesArray
+ return super.bulkInsert(uri, insertValuesArray);
+
+ case INVALID_URI:
+
+ // An invalid URI was passed. Throw an exception
+ throw new IllegalArgumentException("Bulk insert -- Invalid URI:" + uri);
+
+ }
+
+ return -1;
+
+ }
+ /**
+ * Returns an UnsupportedOperationException if delete is called
+ * @see android.content.ContentProvider#delete(Uri, String, String[])
+ * @param uri The content URI
+ * @param selection The SQL WHERE string. Use "?" to mark places that should be substituted by
+ * values in selectionArgs.
+ * @param selectionArgs An array of values that are mapped to each "?" in selection. If no "?"
+ * are used, set this to NULL.
+ *
+ * @return the number of rows deleted
+ */
+ @Override
+ public int delete(Uri uri, String selection, String[] selectionArgs) {
+
+ throw new UnsupportedOperationException("Delete -- unsupported operation " + uri);
+ }
+
+ /**
+ * Updates one or more rows in a table.
+ * @see android.content.ContentProvider#update(Uri, ContentValues, String, String[])
+ * @param uri The content URI for the table
+ * @param values The values to use to update the row or rows. You only need to specify column
+ * names for the columns you want to change. To clear the contents of a column, specify the
+ * column name and NULL for its value.
+ * @param selection An SQL WHERE clause (without the WHERE keyword) specifying the rows to
+ * update. Use "?" to mark places that should be substituted by values in selectionArgs.
+ * @param selectionArgs An array of values that are mapped in order to each "?" in selection.
+ * If no "?" are used, set this to NULL.
+ *
+ * @return int The number of rows updated.
+ */
+ @Override
+ public int update(Uri uri, ContentValues values, String selection,
+ String[] selectionArgs) {
+
+ // Decodes the content URI and choose which insert to use
+ switch (sUriMatcher.match(uri)) {
+
+ // A picture URL content URI
+ case URL_DATE_QUERY:
+
+ // Creats a new writeable database or retrieves a cached one
+ SQLiteDatabase localSQLiteDatabase = mHelper.getWritableDatabase();
+
+ // Updates the table
+ int rows = localSQLiteDatabase.update(
+ DataProviderContract.DATE_TABLE_NAME,
+ values,
+ selection,
+ selectionArgs);
+
+ // If the update succeeded, notify a change and return the number of updated rows.
+ if (0 != rows) {
+ getContext().getContentResolver().notifyChange(uri, null);
+ return rows;
+ } else {
+
+ throw new SQLiteException("Update error:" + uri);
+ }
+
+ case IMAGE_URL_QUERY:
+
+ throw new IllegalArgumentException("Update: Invalid URI: " + uri);
+ }
+
+ return -1;
+ }
+}
diff --git a/samples/training/threadsample/src/com/example/android/threadsample/DataProviderContract.java b/samples/training/threadsample/src/com/example/android/threadsample/DataProviderContract.java
new file mode 100644
index 0000000..e7dd73b
--- /dev/null
+++ b/samples/training/threadsample/src/com/example/android/threadsample/DataProviderContract.java
@@ -0,0 +1,99 @@
+package com.example.android.threadsample;
+
+import android.net.Uri;
+import android.provider.BaseColumns;
+
+/**
+ *
+ * Defines constants for accessing the content provider defined in DataProvider. A content provider
+ * contract assists in accessing the provider's available content URIs, column names, MIME types,
+ * and so forth, without having to know the actual values.
+ */
+public final class DataProviderContract implements BaseColumns {
+
+ private DataProviderContract() { }
+
+ // The URI scheme used for content URIs
+ public static final String SCHEME = "content";
+
+ // The provider's authority
+ public static final String AUTHORITY = "com.example.android.threadsample";
+
+ /**
+ * The DataProvider content URI
+ */
+ public static final Uri CONTENT_URI = Uri.parse(SCHEME + "://" + AUTHORITY);
+
+ /**
+ * The MIME type for a content URI that would return multiple rows
+ * <P>Type: TEXT</P>
+ */
+ public static final String MIME_TYPE_ROWS =
+ "vnd.android.cursor.dir/vnd.com.example.android.threadsample";
+
+ /**
+ * The MIME type for a content URI that would return a single row
+ * <P>Type: TEXT</P>
+ *
+ */
+ public static final String MIME_TYPE_SINGLE_ROW =
+ "vnd.android.cursor.item/vnd.com.example.android.threadsample";
+
+ /**
+ * Picture table primary key column name
+ */
+ public static final String ROW_ID = BaseColumns._ID;
+
+ /**
+ * Picture table name
+ */
+ public static final String PICTUREURL_TABLE_NAME = "PictureUrlData";
+
+ /**
+ * Picture table content URI
+ */
+ public static final Uri PICTUREURL_TABLE_CONTENTURI =
+ Uri.withAppendedPath(CONTENT_URI, PICTUREURL_TABLE_NAME);
+
+ /**
+ * Picture table thumbnail URL column name
+ */
+ public static final String IMAGE_THUMBURL_COLUMN = "ThumbUrl";
+
+ /**
+ * Picture table thumbnail filename column name
+ */
+ public static final String IMAGE_THUMBNAME_COLUMN = "ThumbUrlName";
+
+ /**
+ * Picture table full picture URL column name
+ */
+ public static final String IMAGE_URL_COLUMN = "ImageUrl";
+
+ /**
+ * Picture table full picture filename column name
+ */
+ public static final String IMAGE_PICTURENAME_COLUMN = "ImageName";
+
+ /**
+ * Modification date table name
+ */
+ public static final String DATE_TABLE_NAME = "DateMetadatData";
+
+ /**
+ * Content URI for modification date table
+ */
+ public static final Uri DATE_TABLE_CONTENTURI =
+ Uri.withAppendedPath(CONTENT_URI, DATE_TABLE_NAME);
+
+ /**
+ * Modification date table date column name
+ */
+ public static final String DATA_DATE_COLUMN = "DownloadDate";
+
+ // The content provider database name
+ public static final String DATABASE_NAME = "PictureDataDB";
+
+ // The starting version of the database
+ public static final int DATABASE_VERSION = 1;
+}
diff --git a/samples/training/threadsample/src/com/example/android/threadsample/DisplayActivity.java b/samples/training/threadsample/src/com/example/android/threadsample/DisplayActivity.java
new file mode 100644
index 0000000..f3abdf2
--- /dev/null
+++ b/samples/training/threadsample/src/com/example/android/threadsample/DisplayActivity.java
@@ -0,0 +1,533 @@
+/*
+ * Copyright (C) 2012 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package com.example.android.threadsample;
+
+import android.content.BroadcastReceiver;
+import android.content.Context;
+import android.content.Intent;
+import android.content.IntentFilter;
+import android.os.Build;
+import android.os.Bundle;
+import android.support.v4.app.FragmentActivity;
+import android.support.v4.app.FragmentManager;
+import android.support.v4.app.FragmentManager.OnBackStackChangedListener;
+import android.support.v4.app.FragmentTransaction;
+import android.support.v4.content.LocalBroadcastManager;
+import android.util.Log;
+import android.view.View;
+import android.view.WindowManager;
+
+/**
+ * This activity displays Picasa's current featured images. It uses a service running
+ * a background thread to download Picasa's "featured image" RSS feed.
+ * <p>
+ * An IntentHandler is used to communicate between the active Fragment and this
+ * activity. This pattern simulates some of the communication used between
+ * activities, and allows this activity to make choices of how to manage the
+ * fragments.
+ */
+public class DisplayActivity extends FragmentActivity implements OnBackStackChangedListener {
+
+ // A handle to the main screen view
+ View mMainView;
+
+ // An instance of the status broadcast receiver
+ DownloadStateReceiver mDownloadStateReceiver;
+
+ // Tracks whether Fragments are displaying side-by-side
+ boolean mSideBySide;
+
+ // Tracks whether navigation should be hidden
+ boolean mHideNavigation;
+
+ // Tracks whether the app is in full-screen mode
+ boolean mFullScreen;
+
+ // Tracks the number of Fragments on the back stack
+ int mPreviousStackCount;
+
+ // Instantiates a new broadcast receiver for handling Fragment state
+ private FragmentDisplayer mFragmentDisplayer = new FragmentDisplayer();
+
+ // Sets a tag to use in logging
+ private static final String CLASS_TAG = "DisplayActivity";
+
+ /**
+ * Sets full screen mode on the device, by setting parameters in the current
+ * window and View
+ * @param fullscreen
+ */
+ public void setFullScreen(boolean fullscreen) {
+ // If full screen is set, sets the fullscreen flag in the Window manager
+ getWindow().setFlags(
+ fullscreen ? WindowManager.LayoutParams.FLAG_FULLSCREEN : 0,
+ WindowManager.LayoutParams.FLAG_FULLSCREEN);
+
+ // Sets the global fullscreen flag to the current setting
+ mFullScreen = fullscreen;
+
+ // If the platform version is Android 3.0 (Honeycomb) or above
+ if (Build.VERSION.SDK_INT >= 11) {
+
+ // Sets the View to be "low profile". Status and navigation bar icons will be dimmed
+ int flag = fullscreen ? View.SYSTEM_UI_FLAG_LOW_PROFILE : 0;
+
+ // If the platform version is Android 4.0 (ICS) or above
+ if (Build.VERSION.SDK_INT >= 14 && fullscreen) {
+
+ // Hides all of the navigation icons
+ flag |= View.SYSTEM_UI_FLAG_HIDE_NAVIGATION;
+ }
+
+ // Applies the settings to the screen View
+ mMainView.setSystemUiVisibility(flag);
+
+ // If the user requests a full-screen view, hides the Action Bar.
+ if ( fullscreen ) {
+ this.getActionBar().hide();
+ } else {
+ this.getActionBar().show();
+ }
+ }
+ }
+
+ /*
+ * A callback invoked when the task's back stack changes. This allows the app to
+ * move to the previous state of the Fragment being displayed.
+ *
+ */
+ @Override
+ public void onBackStackChanged() {
+
+ // Gets the previous global stack count
+ int previousStackCount = mPreviousStackCount;
+
+ // Gets a FragmentManager instance
+ FragmentManager localFragmentManager = getSupportFragmentManager();
+
+ // Sets the current back stack count
+ int currentStackCount = localFragmentManager.getBackStackEntryCount();
+
+ // Re-sets the global stack count to be the current count
+ mPreviousStackCount = currentStackCount;
+
+ /*
+ * If the current stack count is less than the previous, something was popped off the stack
+ * probably because the user clicked Back.
+ */
+ boolean popping = currentStackCount < previousStackCount;
+ Log.d(CLASS_TAG, "backstackchanged: popping = " + popping);
+
+ // When going backwards in the back stack, turns off full screen mode.
+ if (popping) {
+ setFullScreen(false);
+ }
+ }
+
+ /*
+ * This callback is invoked by the system when the Activity is being killed
+ * It saves the full screen status, so it can be restored when the Activity is restored
+ *
+ */
+ @Override
+ protected void onSaveInstanceState(Bundle outState) {
+ outState.putBoolean(Constants.EXTENDED_FULLSCREEN, mFullScreen);
+ super.onSaveInstanceState(outState);
+ }
+
+ /*
+ * This callback is invoked when the Activity is first created. It sets up the Activity's
+ * window and initializes the Fragments associated with the Activity
+ */
+ @Override
+ public void onCreate(Bundle stateBundle) {
+ // Sets fullscreen-related flags for the display
+ getWindow().setFlags(
+ WindowManager.LayoutParams.FLAG_LAYOUT_IN_SCREEN
+ | WindowManager.LayoutParams.FLAG_LAYOUT_INSET_DECOR,
+ WindowManager.LayoutParams.FLAG_LAYOUT_IN_SCREEN
+ | WindowManager.LayoutParams.FLAG_LAYOUT_INSET_DECOR);
+
+ // Calls the super method (required)
+ super.onCreate(stateBundle);
+
+ // Inflates the main View, which will be the host View for the fragments
+ mMainView = getLayoutInflater().inflate(R.layout.fragmenthost, null);
+
+ // Sets the content view for the Activity
+ setContentView(mMainView);
+
+ /*
+ * Creates an intent filter for DownloadStateReceiver that intercepts broadcast Intents
+ */
+
+ // The filter's action is BROADCAST_ACTION
+ IntentFilter statusIntentFilter = new IntentFilter(
+ Constants.BROADCAST_ACTION);
+
+ // Sets the filter's category to DEFAULT
+ statusIntentFilter.addCategory(Intent.CATEGORY_DEFAULT);
+
+ // Instantiates a new DownloadStateReceiver
+ mDownloadStateReceiver = new DownloadStateReceiver();
+
+ // Registers the DownloadStateReceiver and its intent filters
+ LocalBroadcastManager.getInstance(this).registerReceiver(
+ mDownloadStateReceiver,
+ statusIntentFilter);
+
+ /*
+ * Creates intent filters for the FragmentDisplayer
+ */
+
+ // One filter is for the action ACTION_VIEW_IMAGE
+ IntentFilter displayerIntentFilter = new IntentFilter(
+ Constants.ACTION_VIEW_IMAGE);
+
+ // Adds a data filter for the HTTP scheme
+ displayerIntentFilter.addDataScheme("http");
+
+ // Registers the receiver
+ LocalBroadcastManager.getInstance(this).registerReceiver(
+ mFragmentDisplayer,
+ displayerIntentFilter);
+
+ // Creates a second filter for ACTION_ZOOM_IMAGE
+ displayerIntentFilter = new IntentFilter(Constants.ACTION_ZOOM_IMAGE);
+
+ // Registers the receiver
+ LocalBroadcastManager.getInstance(this).registerReceiver(
+ mFragmentDisplayer,
+ displayerIntentFilter);
+
+ // Gets an instance of the support library FragmentManager
+ FragmentManager localFragmentManager = getSupportFragmentManager();
+
+ /*
+ * Detects if side-by-side display should be enabled. It's only available on xlarge and
+ * sw600dp devices (for example, tablets). The setting in res/values/ is "false", but this
+ * is overridden in values-xlarge and values-sw600dp.
+ */
+ mSideBySide = getResources().getBoolean(R.bool.sideBySide);
+
+ /*
+ * Detects if hiding navigation controls should be enabled. On xlarge andsw600dp, it should
+ * be false, to avoid having the user enter an additional tap.
+ */
+ mHideNavigation = getResources().getBoolean(R.bool.hideNavigation);
+
+ /*
+ * Adds the back stack change listener defined in this Activity as the listener for the
+ * FragmentManager. See the method onBackStackChanged().
+ */
+ localFragmentManager.addOnBackStackChangedListener(this);
+
+ // If the incoming state of the Activity is null, sets the initial view to be thumbnails
+ if (null == stateBundle) {
+
+ // Starts a Fragment transaction to track the stack
+ FragmentTransaction localFragmentTransaction = localFragmentManager
+ .beginTransaction();
+
+ // Adds the PhotoThumbnailFragment to the host View
+ localFragmentTransaction.add(R.id.fragmentHost,
+ new PhotoThumbnailFragment(), Constants.THUMBNAIL_FRAGMENT_TAG);
+
+ // Commits this transaction to display the Fragment
+ localFragmentTransaction.commit();
+
+ // The incoming state of the Activity isn't null.
+ } else {
+
+ // Gets the previous state of the fullscreen indicator
+ mFullScreen = stateBundle.getBoolean(Constants.EXTENDED_FULLSCREEN);
+
+ // Sets the fullscreen flag to its previous state
+ setFullScreen(mFullScreen);
+
+ // Gets the previous backstack entry count.
+ mPreviousStackCount = localFragmentManager.getBackStackEntryCount();
+ }
+ }
+
+ /*
+ * This callback is invoked when the system is about to destroy the Activity.
+ */
+ @Override
+ public void onDestroy() {
+
+ // If the DownloadStateReceiver still exists, unregister it and set it to null
+ if (mDownloadStateReceiver != null) {
+ LocalBroadcastManager.getInstance(this).unregisterReceiver(mDownloadStateReceiver);
+ mDownloadStateReceiver = null;
+ }
+
+ // Unregisters the FragmentDisplayer instance
+ LocalBroadcastManager.getInstance(this).unregisterReceiver(this.mFragmentDisplayer);
+
+ // Sets the main View to null
+ mMainView = null;
+
+ // Must always call the super method at the end.
+ super.onDestroy();
+ }
+
+ /*
+ * This callback is invoked when the system is stopping the Activity. It stops
+ * background threads.
+ */
+ @Override
+ protected void onStop() {
+
+ // Cancel all the running threads managed by the PhotoManager
+ PhotoManager.cancelAll();
+ super.onStop();
+ }
+
+ /**
+ * This class uses the BroadcastReceiver framework to detect and handle status messages from
+ * the service that downloads URLs.
+ */
+ private class DownloadStateReceiver extends BroadcastReceiver {
+
+ private DownloadStateReceiver() {
+
+ // prevents instantiation by other packages.
+ }
+ /**
+ *
+ * This method is called by the system when a broadcast Intent is matched by this class'
+ * intent filters
+ *
+ * @param context An Android context
+ * @param intent The incoming broadcast Intent
+ */
+ @Override
+ public void onReceive(Context context, Intent intent) {
+
+ /*
+ * Gets the status from the Intent's extended data, and chooses the appropriate action
+ */
+ switch (intent.getIntExtra(Constants.EXTENDED_DATA_STATUS,
+ Constants.STATE_ACTION_COMPLETE)) {
+
+ // Logs "started" state
+ case Constants.STATE_ACTION_STARTED:
+ if (Constants.LOGD) {
+
+ Log.d(CLASS_TAG, "State: STARTED");
+ }
+ break;
+ // Logs "connecting to network" state
+ case Constants.STATE_ACTION_CONNECTING:
+ if (Constants.LOGD) {
+
+ Log.d(CLASS_TAG, "State: CONNECTING");
+ }
+ break;
+ // Logs "parsing the RSS feed" state
+ case Constants.STATE_ACTION_PARSING:
+ if (Constants.LOGD) {
+
+ Log.d(CLASS_TAG, "State: PARSING");
+ }
+ break;
+ // Logs "Writing the parsed data to the content provider" state
+ case Constants.STATE_ACTION_WRITING:
+ if (Constants.LOGD) {
+
+ Log.d(CLASS_TAG, "State: WRITING");
+ }
+ break;
+ // Starts displaying data when the RSS download is complete
+ case Constants.STATE_ACTION_COMPLETE:
+ // Logs the status
+ if (Constants.LOGD) {
+
+ Log.d(CLASS_TAG, "State: COMPLETE");
+ }
+
+ // Finds the fragment that displays thumbnails
+ PhotoThumbnailFragment localThumbnailFragment =
+ (PhotoThumbnailFragment) getSupportFragmentManager().findFragmentByTag(
+ Constants.THUMBNAIL_FRAGMENT_TAG);
+
+ // If the thumbnail Fragment is hidden, don't change its display status
+ if ((localThumbnailFragment == null)
+ || (!localThumbnailFragment.isVisible()))
+ return;
+
+ // Indicates that the thumbnail Fragment is visible
+ localThumbnailFragment.setLoaded(true);
+ break;
+ default:
+ break;
+ }
+ }
+ }
+
+ /**
+ * This class uses the broadcast receiver framework to detect incoming broadcast Intents
+ * and change the currently-visible fragment based on the Intent action.
+ * It adds or replaces Fragments as necessary, depending on how much screen real-estate is
+ * available.
+ */
+ private class FragmentDisplayer extends BroadcastReceiver {
+
+ // Default null constructor
+ public FragmentDisplayer() {
+
+ // Calls the constructor for BroadcastReceiver
+ super();
+ }
+ /**
+ * Receives broadcast Intents for viewing or zooming pictures, and displays the
+ * appropriate Fragment.
+ *
+ * @param context The current Context of the callback
+ * @param intent The broadcast Intent that triggered the callback
+ */
+ @Override
+ public void onReceive(Context context, Intent intent) {
+
+ // Declares a local FragmentManager instance
+ FragmentManager fragmentManager1;
+
+ // Declares a local instance of the Fragment that displays photos
+ PhotoFragment photoFragment;
+
+ // Stores a string representation of the URL in the incoming Intent
+ String urlString;
+
+ // If the incoming Intent is a request is to view an image
+ if (intent.getAction().equals(Constants.ACTION_VIEW_IMAGE)) {
+
+ // Gets an instance of the support library fragment manager
+ fragmentManager1 = getSupportFragmentManager();
+
+ // Gets a handle to the Fragment that displays photos
+ photoFragment =
+ (PhotoFragment) fragmentManager1.findFragmentByTag(
+ Constants.PHOTO_FRAGMENT_TAG
+ );
+
+ // Gets the URL of the picture to display
+ urlString = intent.getDataString();
+
+ // If the photo Fragment exists from a previous display
+ if (null != photoFragment) {
+
+ // If the incoming URL is not already being displayed
+ if (!urlString.equals(photoFragment.getURLString())) {
+
+ // Sets the Fragment to use the URL from the Intent for the photo
+ photoFragment.setPhoto(urlString);
+
+ // Loads the photo into the Fragment
+ photoFragment.loadPhoto();
+ }
+
+ // If the Fragment doesn't already exist
+ } else {
+ // Instantiates a new Fragment
+ photoFragment = new PhotoFragment();
+
+ // Sets the Fragment to use the URL from the Intent for the photo
+ photoFragment.setPhoto(urlString);
+
+ // Starts a new Fragment transaction
+ FragmentTransaction localFragmentTransaction2 =
+ fragmentManager1.beginTransaction();
+
+ // If the fragments are side-by-side, adds the photo Fragment to the display
+ if (mSideBySide) {
+ localFragmentTransaction2.add(
+ R.id.fragmentHost,
+ photoFragment,
+ Constants.PHOTO_FRAGMENT_TAG
+ );
+ /*
+ * If the Fragments are not side-by-side, replaces the current Fragment with
+ * the photo Fragment
+ */
+ } else {
+ localFragmentTransaction2.replace(
+ R.id.fragmentHost,
+ photoFragment,
+ Constants.PHOTO_FRAGMENT_TAG);
+ }
+
+ // Don't remember the transaction (sets the Fragment backstack to null)
+ localFragmentTransaction2.addToBackStack(null);
+
+ // Commits the transaction
+ localFragmentTransaction2.commit();
+ }
+
+ // If not in side-by-side mode, sets "full screen", so that no controls are visible
+ if (!mSideBySide) setFullScreen(true);
+
+ /*
+ * If the incoming Intent is a request to zoom in on an existing image
+ * (Notice that zooming is only supported on large-screen devices)
+ */
+ } else if (intent.getAction().equals(Constants.ACTION_ZOOM_IMAGE)) {
+
+ // If the Fragments are being displayed side-by-side
+ if (mSideBySide) {
+
+ // Gets another instance of the FragmentManager
+ FragmentManager localFragmentManager2 = getSupportFragmentManager();
+
+ // Gets a thumbnail Fragment instance
+ PhotoThumbnailFragment localThumbnailFragment =
+ (PhotoThumbnailFragment) localFragmentManager2.findFragmentByTag(
+ Constants.THUMBNAIL_FRAGMENT_TAG);
+
+ // If the instance exists from a previous display
+ if (null != localThumbnailFragment) {
+
+ // if the existing instance is visible
+ if (localThumbnailFragment.isVisible()) {
+
+ // Starts a fragment transaction
+ FragmentTransaction localFragmentTransaction2 =
+ localFragmentManager2.beginTransaction();
+
+ /*
+ * Hides the current thumbnail, clears the backstack, and commits the
+ * transaction
+ */
+ localFragmentTransaction2.hide(localThumbnailFragment);
+ localFragmentTransaction2.addToBackStack(null);
+ localFragmentTransaction2.commit();
+
+ // If the existing instance is not visible, display it by going "Back"
+ } else {
+
+ // Pops the back stack to show the previous Fragment state
+ localFragmentManager2.popBackStack();
+ }
+ }
+
+ // Removes controls from the screen
+ setFullScreen(true);
+ }
+ }
+ }
+ }
+
+}
diff --git a/samples/training/threadsample/src/com/example/android/threadsample/PhotoDecodeRunnable.java b/samples/training/threadsample/src/com/example/android/threadsample/PhotoDecodeRunnable.java
new file mode 100644
index 0000000..1f867e5
--- /dev/null
+++ b/samples/training/threadsample/src/com/example/android/threadsample/PhotoDecodeRunnable.java
@@ -0,0 +1,288 @@
+/*
+ * Copyright (C) 2012 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.example.android.threadsample;
+
+import android.graphics.Bitmap;
+import android.graphics.BitmapFactory;
+import android.util.Log;
+
+/**
+ * This runnable decodes a byte array containing an image.
+ *
+ * Objects of this class are instantiated and managed by instances of PhotoTask, which
+ * implements the methods {@link TaskRunnableDecodeMethods}. PhotoTask objects call
+ * {@link #PhotoDecodeRunnable(TaskRunnableDecodeMethods) PhotoDecodeRunnable()} with
+ * themselves as the argument. In effect, an PhotoTask object and a
+ * PhotoDecodeRunnable object communicate through the fields of the PhotoTask.
+ *
+ */
+class PhotoDecodeRunnable implements Runnable {
+
+ // Limits the number of times the decoder tries to process an image
+ private static final int NUMBER_OF_DECODE_TRIES = 2;
+
+ // Tells the Runnable to pause for a certain number of milliseconds
+ private static final long SLEEP_TIME_MILLISECONDS = 250;
+
+ // Sets the log tag
+ private static final String LOG_TAG = "PhotoDecodeRunnable";
+
+ // Constants for indicating the state of the decode
+ static final int DECODE_STATE_FAILED = -1;
+ static final int DECODE_STATE_STARTED = 0;
+ static final int DECODE_STATE_COMPLETED = 1;
+
+ // Defines a field that contains the calling object of type PhotoTask.
+ final TaskRunnableDecodeMethods mPhotoTask;
+
+ /**
+ *
+ * An interface that defines methods that PhotoTask implements. An instance of
+ * PhotoTask passes itself to an PhotoDecodeRunnable instance through the
+ * PhotoDecodeRunnable constructor, after which the two instances can access each other's
+ * variables.
+ */
+ interface TaskRunnableDecodeMethods {
+
+ /**
+ * Sets the Thread that this instance is running on
+ * @param currentThread the current Thread
+ */
+ void setImageDecodeThread(Thread currentThread);
+
+ /**
+ * Returns the current contents of the download buffer
+ * @return The byte array downloaded from the URL in the last read
+ */
+ byte[] getByteBuffer();
+
+ /**
+ * Sets the actions for each state of the PhotoTask instance.
+ * @param state The state being handled.
+ */
+ void handleDecodeState(int state);
+
+ /**
+ * Returns the desired width of the image, based on the ImageView being created.
+ * @return The target width
+ */
+ int getTargetWidth();
+
+ /**
+ * Returns the desired height of the image, based on the ImageView being created.
+ * @return The target height.
+ */
+ int getTargetHeight();
+
+ /**
+ * Sets the Bitmap for the ImageView being displayed.
+ * @param image
+ */
+ void setImage(Bitmap image);
+ }
+
+ /**
+ * This constructor creates an instance of PhotoDownloadRunnable and stores in it a reference
+ * to the PhotoTask instance that instantiated it.
+ *
+ * @param downloadTask The PhotoTask, which implements ImageDecoderRunnableCallback
+ */
+ PhotoDecodeRunnable(TaskRunnableDecodeMethods downloadTask) {
+ mPhotoTask = downloadTask;
+ }
+
+ /*
+ * Defines this object's task, which is a set of instructions designed to be run on a Thread.
+ */
+ @Override
+ public void run() {
+
+ /*
+ * Stores the current Thread in the the PhotoTask instance, so that the instance
+ * can interrupt the Thread.
+ */
+ mPhotoTask.setImageDecodeThread(Thread.currentThread());
+
+ /*
+ * Gets the image cache buffer object from the PhotoTask instance. This makes the
+ * to both PhotoDownloadRunnable and PhotoTask.
+ */
+ byte[] imageBuffer = mPhotoTask.getByteBuffer();
+
+ // Defines the Bitmap object that this thread will create
+ Bitmap returnBitmap = null;
+
+ /*
+ * A try block that decodes a downloaded image.
+ *
+ */
+ try {
+
+ /*
+ * Calls the PhotoTask implementation of {@link #handleDecodeState} to
+ * set the state of the download
+ */
+ mPhotoTask.handleDecodeState(DECODE_STATE_STARTED);
+
+ // Sets up options for creating a Bitmap object from the
+ // downloaded image.
+ BitmapFactory.Options bitmapOptions = new BitmapFactory.Options();
+
+ /*
+ * Sets the desired image height and width based on the
+ * ImageView being created.
+ */
+ int targetWidth = mPhotoTask.getTargetWidth();
+ int targetHeight = mPhotoTask.getTargetHeight();
+
+ // Before continuing, checks to see that the Thread hasn't
+ // been interrupted
+ if (Thread.interrupted()) {
+
+ return;
+ }
+
+ /*
+ * Even if the decoder doesn't set a Bitmap, this flag tells
+ * the decoder to return the calculated bounds.
+ */
+ bitmapOptions.inJustDecodeBounds = true;
+
+ /*
+ * First pass of decoding to get scaling and sampling
+ * parameters from the image
+ */
+ BitmapFactory
+ .decodeByteArray(imageBuffer, 0, imageBuffer.length, bitmapOptions);
+
+ /*
+ * Sets horizontal and vertical scaling factors so that the
+ * image is expanded or compressed from its actual size to
+ * the size of the target ImageView
+ */
+ int hScale = bitmapOptions.outHeight / targetHeight;
+ int wScale = bitmapOptions.outWidth / targetWidth;
+
+ /*
+ * Sets the sample size to be larger of the horizontal or
+ * vertical scale factor
+ */
+ //
+ int sampleSize = Math.max(hScale, wScale);
+
+ /*
+ * If either of the scaling factors is > 1, the image's
+ * actual dimension is larger that the available dimension.
+ * This means that the BitmapFactory must compress the image
+ * by the larger of the scaling factors. Setting
+ * inSampleSize accomplishes this.
+ */
+ if (sampleSize > 1) {
+ bitmapOptions.inSampleSize = sampleSize;
+ }
+
+ if (Thread.interrupted()) {
+ return;
+ }
+
+ // Second pass of decoding. If no bitmap is created, nothing
+ // is set in the object.
+ bitmapOptions.inJustDecodeBounds = false;
+
+ /*
+ * This does the actual decoding of the buffer. If the
+ * decode encounters an an out-of-memory error, it may throw
+ * an Exception or an Error, both of which need to be
+ * handled. Once the problem is handled, the decode is
+ * re-tried.
+ */
+ for (int i = 0; i < NUMBER_OF_DECODE_TRIES; i++) {
+ try {
+ // Tries to decode the image buffer
+ returnBitmap = BitmapFactory.decodeByteArray(
+ imageBuffer,
+ 0,
+ imageBuffer.length,
+ bitmapOptions
+ );
+ /*
+ * If the decode works, no Exception or Error has occurred.
+ break;
+
+ /*
+ * If the decode fails, this block tries to get more memory.
+ */
+ } catch (Throwable e) {
+
+ // Logs an error
+ Log.e(LOG_TAG, "Out of memory in decode stage. Throttling.");
+
+ /*
+ * Tells the system that garbage collection is
+ * necessary. Notice that collection may or may not
+ * occur.
+ */
+ java.lang.System.gc();
+
+ if (Thread.interrupted()) {
+ return;
+
+ }
+ /*
+ * Tries to pause the thread for 250 milliseconds,
+ * and catches an Exception if something tries to
+ * activate the thread before it wakes up.
+ */
+ try {
+ Thread.sleep(SLEEP_TIME_MILLISECONDS);
+ } catch (java.lang.InterruptedException interruptException) {
+ return;
+ }
+ }
+ }
+
+ // Catches exceptions if something tries to activate the
+ // Thread incorrectly.
+ } finally {
+ // If the decode failed, there's no bitmap.
+ if (null == returnBitmap) {
+
+ // Sends a failure status to the PhotoTask
+ mPhotoTask.handleDecodeState(DECODE_STATE_FAILED);
+
+ // Logs the error
+ Log.e(LOG_TAG, "Download failed in PhotoDecodeRunnable");
+
+ } else {
+
+ // Sets the ImageView Bitmap
+ mPhotoTask.setImage(returnBitmap);
+
+ // Reports a status of "completed"
+ mPhotoTask.handleDecodeState(DECODE_STATE_COMPLETED);
+ }
+
+ // Sets the current Thread to null, releasing its storage
+ mPhotoTask.setImageDecodeThread(null);
+
+ // Clears the Thread's interrupt flag
+ Thread.interrupted();
+
+ }
+
+ }
+}
diff --git a/samples/training/threadsample/src/com/example/android/threadsample/PhotoDownloadRunnable.java b/samples/training/threadsample/src/com/example/android/threadsample/PhotoDownloadRunnable.java
new file mode 100644
index 0000000..47b6007
--- /dev/null
+++ b/samples/training/threadsample/src/com/example/android/threadsample/PhotoDownloadRunnable.java
@@ -0,0 +1,396 @@
+/*
+ * Copyright (C) ${year} The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.example.android.threadsample;
+
+import com.example.android.threadsample.PhotoDecodeRunnable.TaskRunnableDecodeMethods;
+
+import java.io.EOFException;
+import java.io.IOException;
+import java.io.InputStream;
+import java.net.HttpURLConnection;
+import java.net.URL;
+
+/**
+ * This task downloads bytes from a resource addressed by a URL. When the task
+ * has finished, it calls handleState to report its results.
+ *
+ * Objects of this class are instantiated and managed by instances of PhotoTask, which
+ * implements the methods of {@link TaskRunnableDecodeMethods}. PhotoTask objects call
+ * {@link #PhotoDownloadRunnable(TaskRunnableDownloadMethods) PhotoDownloadRunnable()} with
+ * themselves as the argument. In effect, an PhotoTask object and a
+ * PhotoDownloadRunnable object communicate through the fields of the PhotoTask.
+ */
+class PhotoDownloadRunnable implements Runnable {
+ // Sets the size for each read action (bytes)
+ private static final int READ_SIZE = 1024 * 2;
+
+ // Sets a tag for this class
+ @SuppressWarnings("unused")
+ private static final String LOG_TAG = "PhotoDownloadRunnable";
+
+ // Constants for indicating the state of the download
+ static final int HTTP_STATE_FAILED = -1;
+ static final int HTTP_STATE_STARTED = 0;
+ static final int HTTP_STATE_COMPLETED = 1;
+
+ // Defines a field that contains the calling object of type PhotoTask.
+ final TaskRunnableDownloadMethods mPhotoTask;
+
+ /**
+ *
+ * An interface that defines methods that PhotoTask implements. An instance of
+ * PhotoTask passes itself to an PhotoDownloadRunnable instance through the
+ * PhotoDownloadRunnable constructor, after which the two instances can access each other's
+ * variables.
+ */
+ interface TaskRunnableDownloadMethods {
+
+ /**
+ * Sets the Thread that this instance is running on
+ * @param currentThread the current Thread
+ */
+ void setDownloadThread(Thread currentThread);
+
+ /**
+ * Returns the current contents of the download buffer
+ * @return The byte array downloaded from the URL in the last read
+ */
+ byte[] getByteBuffer();
+
+ /**
+ * Sets the current contents of the download buffer
+ * @param buffer The bytes that were just read
+ */
+ void setByteBuffer(byte[] buffer);
+
+ /**
+ * Defines the actions for each state of the PhotoTask instance.
+ * @param state The current state of the task
+ */
+ void handleDownloadState(int state);
+
+ /**
+ * Gets the URL for the image being downloaded
+ * @return The image URL
+ */
+ URL getImageURL();
+ }
+
+ /**
+ * This constructor creates an instance of PhotoDownloadRunnable and stores in it a reference
+ * to the PhotoTask instance that instantiated it.
+ *
+ * @param photoTask The PhotoTask, which implements TaskRunnableDecodeMethods
+ */
+ PhotoDownloadRunnable(TaskRunnableDownloadMethods photoTask) {
+ mPhotoTask = photoTask;
+ }
+
+ /*
+ * Defines this object's task, which is a set of instructions designed to be run on a Thread.
+ */
+ @SuppressWarnings("resource")
+ @Override
+ public void run() {
+
+ /*
+ * Stores the current Thread in the the PhotoTask instance, so that the instance
+ * can interrupt the Thread.
+ */
+ mPhotoTask.setDownloadThread(Thread.currentThread());
+
+ // Moves the current Thread into the background
+ android.os.Process.setThreadPriority(android.os.Process.THREAD_PRIORITY_BACKGROUND);
+
+ /*
+ * Gets the image cache buffer object from the PhotoTask instance. This makes the
+ * to both PhotoDownloadRunnable and PhotoTask.
+ */
+ byte[] byteBuffer = mPhotoTask.getByteBuffer();
+
+ /*
+ * A try block that downloads a Picasa image from a URL. The URL value is in the field
+ * PhotoTask.mImageURL
+ */
+ // Tries to download the picture from Picasa
+ try {
+ // Before continuing, checks to see that the Thread hasn't been
+ // interrupted
+ if (Thread.interrupted()) {
+
+ throw new InterruptedException();
+ }
+
+ // If there's no cache buffer for this image
+ if (null == byteBuffer) {
+
+ /*
+ * Calls the PhotoTask implementation of {@link #handleDownloadState} to
+ * set the state of the download
+ */
+ mPhotoTask.handleDownloadState(HTTP_STATE_STARTED);
+
+ // Defines a handle for the byte download stream
+ InputStream byteStream = null;
+
+ // Downloads the image and catches IO errors
+ try {
+
+ // Opens an HTTP connection to the image's URL
+ HttpURLConnection httpConn =
+ (HttpURLConnection) mPhotoTask.getImageURL().openConnection();
+
+ // Sets the user agent to report to the server
+ httpConn.setRequestProperty("User-Agent", Constants.USER_AGENT);
+
+ // Before continuing, checks to see that the Thread
+ // hasn't been interrupted
+ if (Thread.interrupted()) {
+
+ throw new InterruptedException();
+ }
+ // Gets the input stream containing the image
+ byteStream = httpConn.getInputStream();
+
+ if (Thread.interrupted()) {
+
+ throw new InterruptedException();
+ }
+ /*
+ * Gets the size of the file being downloaded. This
+ * may or may not be returned.
+ */
+ int contentSize = httpConn.getContentLength();
+
+ /*
+ * If the size of the image isn't available
+ */
+ if (-1 == contentSize) {
+
+ // Allocates a temporary buffer
+ byte[] tempBuffer = new byte[READ_SIZE];
+
+ // Records the initial amount of available space
+ int bufferLeft = tempBuffer.length;
+
+ /*
+ * Defines the initial offset of the next available
+ * byte in the buffer, and the initial result of
+ * reading the binary
+ */
+ int bufferOffset = 0;
+ int readResult = 0;
+
+ /*
+ * The "outer" loop continues until all the bytes
+ * have been downloaded. The inner loop continues
+ * until the temporary buffer is full, and then
+ * allocates more buffer space.
+ */
+ outer: do {
+ while (bufferLeft > 0) {
+
+ /*
+ * Reads from the URL location into
+ * the temporary buffer, starting at the
+ * next available free byte and reading as
+ * many bytes as are available in the
+ * buffer.
+ */
+ readResult = byteStream.read(tempBuffer, bufferOffset,
+ bufferLeft);
+
+ /*
+ * InputStream.read() returns zero when the
+ * file has been completely read.
+ */
+ if (readResult < 0) {
+ // The read is finished, so this breaks
+ // the to "outer" loop
+ break outer;
+ }
+
+ /*
+ * The read isn't finished. This sets the
+ * next available open position in the
+ * buffer (the buffer index is 0-based).
+ */
+ bufferOffset += readResult;
+
+ // Subtracts the number of bytes read from
+ // the amount of buffer left
+ bufferLeft -= readResult;
+
+ if (Thread.interrupted()) {
+
+ throw new InterruptedException();
+ }
+ }
+ /*
+ * The temporary buffer is full, so the
+ * following code creates a new buffer that can
+ * contain the existing contents plus the next
+ * read cycle.
+ */
+
+ // Resets the amount of buffer left to be the
+ // max buffer size
+ bufferLeft = READ_SIZE;
+
+ /*
+ * Sets a new size that can contain the existing
+ * buffer's contents plus space for the next
+ * read cycle.
+ */
+ int newSize = tempBuffer.length + READ_SIZE;
+
+ /*
+ * Creates a new temporary buffer, moves the
+ * contents of the old temporary buffer into it,
+ * and then points the temporary buffer variable
+ * to the new buffer.
+ */
+ byte[] expandedBuffer = new byte[newSize];
+ System.arraycopy(tempBuffer, 0, expandedBuffer, 0,
+ tempBuffer.length);
+ tempBuffer = expandedBuffer;
+ } while (true);
+
+ /*
+ * When the entire image has been read, this creates
+ * a permanent byte buffer with the same size as
+ * the number of used bytes in the temporary buffer
+ * (equal to the next open byte, because tempBuffer
+ * is 0=based).
+ */
+ byteBuffer = new byte[bufferOffset];
+
+ // Copies the temporary buffer to the image buffer
+ System.arraycopy(tempBuffer, 0, byteBuffer, 0, bufferOffset);
+
+ /*
+ * The download size is available, so this creates a
+ * permanent buffer of that length.
+ */
+ } else {
+ byteBuffer = new byte[contentSize];
+
+ // How much of the buffer still remains empty
+ int remainingLength = contentSize;
+
+ // The next open space in the buffer
+ int bufferOffset = 0;
+
+ /*
+ * Reads into the buffer until the number of bytes
+ * equal to the length of the buffer (the size of
+ * the image) have been read.
+ */
+ while (remainingLength > 0) {
+ int readResult = byteStream.read(
+ byteBuffer,
+ bufferOffset,
+ remainingLength);
+ /*
+ * EOF should not occur, because the loop should
+ * read the exact # of bytes in the image
+ */
+ if (readResult < 0) {
+
+ // Throws an EOF Exception
+ throw new EOFException();
+ }
+
+ // Moves the buffer offset to the next open byte
+ bufferOffset += readResult;
+
+ // Subtracts the # of bytes read from the
+ // remaining length
+ remainingLength -= readResult;
+
+ if (Thread.interrupted()) {
+
+ throw new InterruptedException();
+ }
+ }
+ }
+
+ if (Thread.interrupted()) {
+
+ throw new InterruptedException();
+ }
+
+ // If an IO error occurs, returns immediately
+ } catch (IOException e) {
+ e.printStackTrace();
+ return;
+
+ /*
+ * If the input stream is still open, close it
+ */
+ } finally {
+ if (null != byteStream) {
+ try {
+ byteStream.close();
+ } catch (Exception e) {
+
+ }
+ }
+ }
+ }
+
+ /*
+ * Stores the downloaded bytes in the byte buffer in the PhotoTask instance.
+ */
+ mPhotoTask.setByteBuffer(byteBuffer);
+
+ /*
+ * Sets the status message in the PhotoTask instance. This sets the
+ * ImageView background to indicate that the image is being
+ * decoded.
+ */
+ mPhotoTask.handleDownloadState(HTTP_STATE_COMPLETED);
+
+ // Catches exceptions thrown in response to a queued interrupt
+ } catch (InterruptedException e1) {
+
+ // Does nothing
+
+ // In all cases, handle the results
+ } finally {
+
+ // If the byteBuffer is null, reports that the download failed.
+ if (null == byteBuffer) {
+ mPhotoTask.handleDownloadState(HTTP_STATE_FAILED);
+ }
+
+ /*
+ * The implementation of setHTTPDownloadThread() in PhotoTask calls
+ * PhotoTask.setCurrentThread(), which then locks on the static ThreadPool
+ * object and returns the current thread. Locking keeps all references to Thread
+ * objects the same until the reference to the current Thread is deleted.
+ */
+
+ // Sets the reference to the current Thread to null, releasing its storage
+ mPhotoTask.setDownloadThread(null);
+
+ // Clears the Thread's interrupt flag
+ Thread.interrupted();
+ }
+ }
+}
+
diff --git a/samples/training/threadsample/src/com/example/android/threadsample/PhotoFragment.java b/samples/training/threadsample/src/com/example/android/threadsample/PhotoFragment.java
new file mode 100644
index 0000000..9b2ce01
--- /dev/null
+++ b/samples/training/threadsample/src/com/example/android/threadsample/PhotoFragment.java
@@ -0,0 +1,187 @@
+/*
+ * Copyright (C) 2012 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.example.android.threadsample;
+
+import android.content.Intent;
+import android.os.Bundle;
+import android.support.v4.app.Fragment;
+import android.support.v4.app.ShareCompat;
+import android.support.v4.content.LocalBroadcastManager;
+import android.util.Log;
+import android.view.LayoutInflater;
+import android.view.View;
+import android.view.ViewGroup;
+
+import java.net.MalformedURLException;
+import java.net.URL;
+
+public class PhotoFragment extends Fragment implements View.OnClickListener {
+ // Constants
+ private static final String LOG_TAG = "ImageDownloaderThread";
+ private static final String PHOTO_URL_KEY = "com.example.android.threadsample.PHOTO_URL_KEY";
+
+ PhotoView mPhotoView;
+
+ String mURLString;
+
+ ShareCompat.IntentBuilder mShareCompatIntentBuilder;
+
+ /**
+ * Converts the stored URL string to a URL, and then tries to download the picture from that
+ * URL.
+ */
+ public void loadPhoto() {
+ // If setPhoto() was called to store a URL, proceed
+ if (mURLString != null) {
+
+ // Handles invalid URLs
+ try {
+
+ // Converts the URL string to a valid URL
+ URL localURL = new URL(mURLString);
+
+ /*
+ * setImageURL(url,false,null) attempts to download and decode the picture at
+ * at "url" without caching and without providing a Drawable. The result will be
+ * a BitMap stored in the PhotoView for this Fragment.
+ */
+ mPhotoView.setImageURL(localURL, false, null);
+
+ // Catches an invalid URL format
+ } catch (MalformedURLException localMalformedURLException) {
+ localMalformedURLException.printStackTrace();
+ }
+ }
+ }
+ /**
+ * Returns the stored URL string
+ * @return The URL of the picture being shown by this Fragment, in String format
+ */
+ public String getURLString() {
+ return mURLString;
+ }
+
+ /*
+ * This callback is invoked when users click on a displayed image. The input argument is
+ * a handle to the View object that was clicked
+ */
+ @Override
+ public void onClick(View view) {
+
+ // Sends a broadcast intent to zoom the image
+ Intent localIntent = new Intent(Constants.ACTION_ZOOM_IMAGE);
+ LocalBroadcastManager.getInstance(getActivity()).sendBroadcast(localIntent);
+ }
+
+ /*
+ * This callback is invoked when the Fragment is created.
+ */
+ @Override
+ public void onCreate(Bundle bundle) {
+ super.onCreate(bundle);
+ }
+
+ /*
+ * This callback is invoked as the Fragment's View is being constructed.
+ */
+ @Override
+ public View onCreateView(LayoutInflater inflater, ViewGroup viewGroup, Bundle bundle) {
+ super.onCreateView(inflater, viewGroup, bundle);
+
+ /*
+ * Creates a View from the specified layout file. The layout uses the parameters specified
+ * in viewGroup, but is not attached to any parent
+ */
+ View localView = inflater.inflate(R.layout.photo, viewGroup, false);
+
+ // Gets a handle to the PhotoView View in the layout
+ mPhotoView = ((PhotoView) localView.findViewById(R.id.photoView));
+
+ /*
+ * The click listener becomes this class (PhotoFragment). The onClick() method in this
+ * class is invoked when users click a photo.
+ */
+ mPhotoView.setOnClickListener(this);
+
+ // If the bundle argument contains data, uses it as a URL for the picture to display
+ if (bundle != null) {
+ mURLString = bundle.getString(PHOTO_URL_KEY);
+ }
+
+ if (mURLString != null)
+ loadPhoto();
+
+ // Returns the resulting View
+ return localView;
+ }
+
+ /*
+ * This callback is invoked as the Fragment's View is being destroyed
+ */
+ @Override
+ public void onDestroyView() {
+ // Logs the destroy operation
+ Log.d(LOG_TAG, "onDestroyView");
+
+ // If the View object still exists, delete references to avoid memory leaks
+ if (mPhotoView != null) {
+
+ mPhotoView.setOnClickListener(null);
+ this.mPhotoView = null;
+ }
+
+ // Always call the super method last
+ super.onDestroyView();
+ }
+
+ /*
+ * This callback is invoked when the Fragment is no longer attached to its Activity.
+ * Sets the URL for the Fragment to null
+ */
+ @Override
+ public void onDetach() {
+ // Logs the detach
+ Log.d(LOG_TAG, "onDetach");
+
+ // Removes the reference to the URL
+ mURLString = null;
+
+ // Always call the super method last
+ super.onDetach();
+ }
+
+ /*
+ * This callback is invoked if the system asks the Fragment to save its state. This allows the
+ * the system to restart the Fragment later on.
+ */
+ @Override
+ public void onSaveInstanceState(Bundle bundle) {
+ // Always call the super method first
+ super.onSaveInstanceState(bundle);
+
+ // Puts the current URL for the picture being shown into the saved state
+ bundle.putString(PHOTO_URL_KEY, mURLString);
+ }
+
+ /**
+ * Sets the photo for this Fragment, by storing a URL that points to a picture
+ * @param urlString A String representation of the URL pointing to the picture
+ */
+ public void setPhoto(String urlString) {
+ mURLString = urlString;
+ }
+}
diff --git a/samples/training/threadsample/src/com/example/android/threadsample/PhotoManager.java b/samples/training/threadsample/src/com/example/android/threadsample/PhotoManager.java
new file mode 100644
index 0000000..783b0a3
--- /dev/null
+++ b/samples/training/threadsample/src/com/example/android/threadsample/PhotoManager.java
@@ -0,0 +1,446 @@
+/*
+ * Copyright (C) 2012 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.example.android.threadsample;
+
+import android.annotation.SuppressLint;
+import android.os.Handler;
+import android.os.Looper;
+import android.os.Message;
+import android.support.v4.util.LruCache;
+
+import java.net.URL;
+import java.util.Queue;
+import java.util.concurrent.BlockingQueue;
+import java.util.concurrent.LinkedBlockingQueue;
+import java.util.concurrent.ThreadPoolExecutor;
+import java.util.concurrent.TimeUnit;
+
+/**
+ * This class creates pools of background threads for downloading
+ * Picasa images from the web, based on URLs retrieved from Picasa's featured images RSS feed.
+ * The class is implemented as a singleton; the only way to get an PhotoManager instance is to
+ * call {@link #getInstance}.
+ * <p>
+ * The class sets the pool size and cache size based on the particular operation it's performing.
+ * The algorithm doesn't apply to all situations, so if you re-use the code to implement a pool
+ * of threads for your own app, you will have to come up with your choices for pool size, cache
+ * size, and so forth. In many cases, you'll have to set some numbers arbitrarily and then
+ * measure the impact on performance.
+ * <p>
+ * This class actually uses two threadpools in order to limit the number of
+ * simultaneous image decoding threads to the number of available processor
+ * cores.
+ * <p>
+ * Finally, this class defines a handler that communicates back to the UI
+ * thread to change the bitmap to reflect the state.
+ */
+@SuppressWarnings("unused")
+public class PhotoManager {
+ /*
+ * Status indicators
+ */
+ static final int DOWNLOAD_FAILED = -1;
+ static final int DOWNLOAD_STARTED = 1;
+ static final int DOWNLOAD_COMPLETE = 2;
+ static final int DECODE_STARTED = 3;
+ static final int TASK_COMPLETE = 4;
+
+ // Sets the size of the storage that's used to cache images
+ private static final int IMAGE_CACHE_SIZE = 1024 * 1024 * 4;
+
+ // Sets the amount of time an idle thread will wait for a task before terminating
+ private static final int KEEP_ALIVE_TIME = 1;
+
+ // Sets the Time Unit to seconds
+ private static final TimeUnit KEEP_ALIVE_TIME_UNIT;
+
+ // Sets the initial threadpool size to 8
+ private static final int CORE_POOL_SIZE = 8;
+
+ // Sets the maximum threadpool size to 8
+ private static final int MAXIMUM_POOL_SIZE = 8;
+
+ /**
+ * NOTE: This is the number of total available cores. On current versions of
+ * Android, with devices that use plug-and-play cores, this will return less
+ * than the total number of cores. The total number of cores is not
+ * available in current Android implementations.
+ */
+ private static int NUMBER_OF_CORES = Runtime.getRuntime().availableProcessors();
+
+ /*
+ * Creates a cache of byte arrays indexed by image URLs. As new items are added to the
+ * cache, the oldest items are ejected and subject to garbage collection.
+ */
+ private final LruCache<URL, byte[]> mPhotoCache;
+
+ // A queue of Runnables for the image download pool
+ private final BlockingQueue<Runnable> mDownloadWorkQueue;
+
+ // A queue of Runnables for the image decoding pool
+ private final BlockingQueue<Runnable> mDecodeWorkQueue;
+
+ // A queue of PhotoManager tasks. Tasks are handed to a ThreadPool.
+ private final Queue<PhotoTask> mPhotoTaskWorkQueue;
+
+ // A managed pool of background download threads
+ private final ThreadPoolExecutor mDownloadThreadPool;
+
+ // A managed pool of background decoder threads
+ private final ThreadPoolExecutor mDecodeThreadPool;
+
+ // An object that manages Messages in a Thread
+ private Handler mHandler;
+
+ // A single instance of PhotoManager, used to implement the singleton pattern
+ private static PhotoManager sInstance = null;
+
+ // A static block that sets class fields
+ static {
+
+ // The time unit for "keep alive" is in seconds
+ KEEP_ALIVE_TIME_UNIT = TimeUnit.SECONDS;
+
+ // Creates a single static instance of PhotoManager
+ sInstance = new PhotoManager();
+ }
+ /**
+ * Constructs the work queues and thread pools used to download and decode images.
+ */
+ private PhotoManager() {
+
+ /*
+ * Creates a work queue for the pool of Thread objects used for downloading, using a linked
+ * list queue that blocks when the queue is empty.
+ */
+ mDownloadWorkQueue = new LinkedBlockingQueue<Runnable>();
+
+ /*
+ * Creates a work queue for the pool of Thread objects used for decoding, using a linked
+ * list queue that blocks when the queue is empty.
+ */
+ mDecodeWorkQueue = new LinkedBlockingQueue<Runnable>();
+
+ /*
+ * Creates a work queue for the set of of task objects that control downloading and
+ * decoding, using a linked list queue that blocks when the queue is empty.
+ */
+ mPhotoTaskWorkQueue = new LinkedBlockingQueue<PhotoTask>();
+
+ /*
+ * Creates a new pool of Thread objects for the download work queue
+ */
+ mDownloadThreadPool = new ThreadPoolExecutor(CORE_POOL_SIZE, MAXIMUM_POOL_SIZE,
+ KEEP_ALIVE_TIME, KEEP_ALIVE_TIME_UNIT, mDownloadWorkQueue);
+
+ /*
+ * Creates a new pool of Thread objects for the decoding work queue
+ */
+ mDecodeThreadPool = new ThreadPoolExecutor(NUMBER_OF_CORES, NUMBER_OF_CORES,
+ KEEP_ALIVE_TIME, KEEP_ALIVE_TIME_UNIT, mDecodeWorkQueue);
+
+ // Instantiates a new cache based on the cache size estimate
+ mPhotoCache = new LruCache<URL, byte[]>(IMAGE_CACHE_SIZE) {
+
+ /*
+ * This overrides the default sizeOf() implementation to return the
+ * correct size of each cache entry.
+ */
+
+ @Override
+ protected int sizeOf(URL paramURL, byte[] paramArrayOfByte) {
+ return paramArrayOfByte.length;
+ }
+ };
+ /*
+ * Instantiates a new anonymous Handler object and defines its
+ * handleMessage() method. The Handler *must* run on the UI thread, because it moves photo
+ * Bitmaps from the PhotoTask object to the View object.
+ * To force the Handler to run on the UI thread, it's defined as part of the PhotoManager
+ * constructor. The constructor is invoked when the class is first referenced, and that
+ * happens when the View invokes startDownload. Since the View runs on the UI Thread, so
+ * does the constructor and the Handler.
+ */
+ mHandler = new Handler(Looper.getMainLooper()) {
+
+ /*
+ * handleMessage() defines the operations to perform when the
+ * Handler receives a new Message to process.
+ */
+ @Override
+ public void handleMessage(Message inputMessage) {
+
+ // Gets the image task from the incoming Message object.
+ PhotoTask photoTask = (PhotoTask) inputMessage.obj;
+
+ // Sets an PhotoView that's a weak reference to the
+ // input ImageView
+ PhotoView localView = photoTask.getPhotoView();
+
+ // If this input view isn't null
+ if (localView != null) {
+
+ /*
+ * Gets the URL of the *weak reference* to the input
+ * ImageView. The weak reference won't have changed, even if
+ * the input ImageView has.
+ */
+ URL localURL = localView.getLocation();
+
+ /*
+ * Compares the URL of the input ImageView to the URL of the
+ * weak reference. Only updates the bitmap in the ImageView
+ * if this particular Thread is supposed to be serving the
+ * ImageView.
+ */
+ if (photoTask.getImageURL() == localURL)
+
+ /*
+ * Chooses the action to take, based on the incoming message
+ */
+ switch (inputMessage.what) {
+
+ // If the download has started, sets background color to dark green
+ case DOWNLOAD_STARTED:
+ localView.setStatusResource(R.drawable.imagedownloading);
+ break;
+
+ /*
+ * If the download is complete, but the decode is waiting, sets the
+ * background color to golden yellow
+ */
+ case DOWNLOAD_COMPLETE:
+ // Sets background color to golden yellow
+ localView.setStatusResource(R.drawable.decodequeued);
+ break;
+ // If the decode has started, sets background color to orange
+ case DECODE_STARTED:
+ localView.setStatusResource(R.drawable.decodedecoding);
+ break;
+ /*
+ * The decoding is done, so this sets the
+ * ImageView's bitmap to the bitmap in the
+ * incoming message
+ */
+ case TASK_COMPLETE:
+ localView.setImageBitmap(photoTask.getImage());
+ recycleTask(photoTask);
+ break;
+ // The download failed, sets the background color to dark red
+ case DOWNLOAD_FAILED:
+ localView.setStatusResource(R.drawable.imagedownloadfailed);
+
+ // Attempts to re-use the Task object
+ recycleTask(photoTask);
+ break;
+ default:
+ // Otherwise, calls the super method
+ super.handleMessage(inputMessage);
+ }
+ }
+ }
+ };
+ }
+
+ /**
+ * Returns the PhotoManager object
+ * @return The global PhotoManager object
+ */
+ public static PhotoManager getInstance() {
+
+ return sInstance;
+ }
+
+ /**
+ * Handles state messages for a particular task object
+ * @param photoTask A task object
+ * @param state The state of the task
+ */
+ @SuppressLint("HandlerLeak")
+ public void handleState(PhotoTask photoTask, int state) {
+ switch (state) {
+
+ // The task finished downloading and decoding the image
+ case TASK_COMPLETE:
+
+ // Puts the image into cache
+ if (photoTask.isCacheEnabled()) {
+ // If the task is set to cache the results, put the buffer
+ // that was
+ // successfully decoded into the cache
+ mPhotoCache.put(photoTask.getImageURL(), photoTask.getByteBuffer());
+ }
+
+ // Gets a Message object, stores the state in it, and sends it to the Handler
+ Message completeMessage = mHandler.obtainMessage(state, photoTask);
+ completeMessage.sendToTarget();
+ break;
+
+ // The task finished downloading the image
+ case DOWNLOAD_COMPLETE:
+ /*
+ * Decodes the image, by queuing the decoder object to run in the decoder
+ * thread pool
+ */
+ mDecodeThreadPool.execute(photoTask.getPhotoDecodeRunnable());
+
+ // In all other cases, pass along the message without any other action.
+ default:
+ mHandler.obtainMessage(state, photoTask).sendToTarget();
+ break;
+ }
+
+ }
+
+ /**
+ * Cancels all Threads in the ThreadPool
+ */
+ public static void cancelAll() {
+
+ /*
+ * Creates an array of tasks that's the same size as the task work queue
+ */
+ PhotoTask[] taskArray = new PhotoTask[sInstance.mDownloadWorkQueue.size()];
+
+ // Populates the array with the task objects in the queue
+ sInstance.mDownloadWorkQueue.toArray(taskArray);
+
+ // Stores the array length in order to iterate over the array
+ int taskArraylen = taskArray.length;
+
+ /*
+ * Locks on the singleton to ensure that other processes aren't mutating Threads, then
+ * iterates over the array of tasks and interrupts the task's current Thread.
+ */
+ synchronized (sInstance) {
+
+ // Iterates over the array of tasks
+ for (int taskArrayIndex = 0; taskArrayIndex < taskArraylen; taskArrayIndex++) {
+
+ // Gets the task's current thread
+ Thread thread = taskArray[taskArrayIndex].mThreadThis;
+
+ // if the Thread exists, post an interrupt to it
+ if (null != thread) {
+ thread.interrupt();
+ }
+ }
+ }
+ }
+
+ /**
+ * Stops a download Thread and removes it from the threadpool
+ *
+ * @param downloaderTask The download task associated with the Thread
+ * @param pictureURL The URL being downloaded
+ */
+ static public void removeDownload(PhotoTask downloaderTask, URL pictureURL) {
+
+ // If the Thread object still exists and the download matches the specified URL
+ if (downloaderTask != null && downloaderTask.getImageURL().equals(pictureURL)) {
+
+ /*
+ * Locks on this class to ensure that other processes aren't mutating Threads.
+ */
+ synchronized (sInstance) {
+
+ // Gets the Thread that the downloader task is running on
+ Thread thread = downloaderTask.getCurrentThread();
+
+ // If the Thread exists, posts an interrupt to it
+ if (null != thread)
+ thread.interrupt();
+ }
+ /*
+ * Removes the download Runnable from the ThreadPool. This opens a Thread in the
+ * ThreadPool's work queue, allowing a task in the queue to start.
+ */
+ sInstance.mDownloadThreadPool.remove(downloaderTask.getHTTPDownloadRunnable());
+ }
+ }
+
+ /**
+ * Starts an image download and decode
+ *
+ * @param imageView The ImageView that will get the resulting Bitmap
+ * @param cacheFlag Determines if caching should be used
+ * @return The task instance that will handle the work
+ */
+ static public PhotoTask startDownload(
+ PhotoView imageView,
+ boolean cacheFlag) {
+
+ /*
+ * Gets a task from the pool of tasks, returning null if the pool is empty
+ */
+ PhotoTask downloadTask = sInstance.mPhotoTaskWorkQueue.poll();
+
+ // If the queue was empty, create a new task instead.
+ if (null == downloadTask) {
+ downloadTask = new PhotoTask();
+ }
+
+ // Initializes the task
+ downloadTask.initializeDownloaderTask(PhotoManager.sInstance, imageView, cacheFlag);
+
+ /*
+ * Provides the download task with the cache buffer corresponding to the URL to be
+ * downloaded.
+ */
+ downloadTask.setByteBuffer(sInstance.mPhotoCache.get(downloadTask.getImageURL()));
+
+ // If the byte buffer was empty, the image wasn't cached
+ if (null == downloadTask.getByteBuffer()) {
+
+ /*
+ * "Executes" the tasks' download Runnable in order to download the image. If no
+ * Threads are available in the thread pool, the Runnable waits in the queue.
+ */
+ sInstance.mDownloadThreadPool.execute(downloadTask.getHTTPDownloadRunnable());
+
+ // Sets the display to show that the image is queued for downloading and decoding.
+ imageView.setStatusResource(R.drawable.imagequeued);
+
+ // The image was cached, so no download is required.
+ } else {
+
+ /*
+ * Signals that the download is "complete", because the byte array already contains the
+ * undecoded image. The decoding starts.
+ */
+
+ sInstance.handleState(downloadTask, DOWNLOAD_COMPLETE);
+ }
+
+ // Returns a task object, either newly-created or one from the task pool
+ return downloadTask;
+ }
+
+ /**
+ * Recycles tasks by calling their internal recycle() method and then putting them back into
+ * the task queue.
+ * @param downloadTask The task to recycle
+ */
+ void recycleTask(PhotoTask downloadTask) {
+
+ // Frees up memory in the task
+ downloadTask.recycle();
+
+ // Puts the task object back into the queue for re-use.
+ mPhotoTaskWorkQueue.offer(downloadTask);
+ }
+}
diff --git a/samples/training/threadsample/src/com/example/android/threadsample/PhotoTask.java b/samples/training/threadsample/src/com/example/android/threadsample/PhotoTask.java
new file mode 100644
index 0000000..b07c497
--- /dev/null
+++ b/samples/training/threadsample/src/com/example/android/threadsample/PhotoTask.java
@@ -0,0 +1,298 @@
+/*
+ * Copyright (C) 2012 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.example.android.threadsample;
+
+import com.example.android.threadsample.PhotoDecodeRunnable.TaskRunnableDecodeMethods;
+import com.example.android.threadsample.PhotoDownloadRunnable.TaskRunnableDownloadMethods;
+
+import android.graphics.Bitmap;
+
+import java.lang.ref.WeakReference;
+import java.net.URL;
+
+/**
+ * This class manages PhotoDownloadRunnable and PhotoDownloadRunnable objects. It does't perform
+ * the download or decode; instead, it manages persistent storage for the tasks that do the work.
+ * It does this by implementing the interfaces that the download and decode classes define, and
+ * then passing itself as an argument to the constructor of a download or decode object. In effect,
+ * this allows PhotoTask to start on a Thread, run a download in a delegate object, then
+ * run a decode, and then start over again. This class can be pooled and reused as necessary.
+ */
+public class PhotoTask implements
+ TaskRunnableDownloadMethods, TaskRunnableDecodeMethods {
+
+ /*
+ * Creates a weak reference to the ImageView that this Task will populate.
+ * The weak reference prevents memory leaks and crashes, because it
+ * automatically tracks the "state" of the variable it backs. If the
+ * reference becomes invalid, the weak reference is garbage- collected. This
+ * technique is important for referring to objects that are part of a
+ * component lifecycle. Using a hard reference may cause memory leaks as the
+ * value continues to change; even worse, it can cause crashes if the
+ * underlying component is destroyed. Using a weak reference to a View
+ * ensures that the reference is more transitory in nature.
+ */
+ private WeakReference<PhotoView> mImageWeakRef;
+
+ // The image's URL
+ private URL mImageURL;
+
+ // The width and height of the decoded image
+ private int mTargetHeight;
+ private int mTargetWidth;
+
+ // Is the cache enabled for this transaction?
+ private boolean mCacheEnabled;
+
+ /*
+ * Field containing the Thread this task is running on.
+ */
+ Thread mThreadThis;
+
+ /*
+ * Fields containing references to the two runnable objects that handle downloading and
+ * decoding of the image.
+ */
+ private Runnable mDownloadRunnable;
+ private Runnable mDecodeRunnable;
+
+ // A buffer for containing the bytes that make up the image
+ byte[] mImageBuffer;
+
+ // The decoded image
+ private Bitmap mDecodedImage;
+
+ // The Thread on which this task is currently running.
+ private Thread mCurrentThread;
+
+ /*
+ * An object that contains the ThreadPool singleton.
+ */
+ private static PhotoManager sPhotoManager;
+
+ /**
+ * Creates an PhotoTask containing a download object and a decoder object.
+ */
+ PhotoTask() {
+ // Create the runnables
+ mDownloadRunnable = new PhotoDownloadRunnable(this);
+ mDecodeRunnable = new PhotoDecodeRunnable(this);
+ sPhotoManager = PhotoManager.getInstance();
+ }
+
+ /**
+ * Initializes the Task
+ *
+ * @param photoManager A ThreadPool object
+ * @param photoView An ImageView instance that shows the downloaded image
+ * @param cacheFlag Whether caching is enabled
+ */
+ void initializeDownloaderTask(
+ PhotoManager photoManager,
+ PhotoView photoView,
+ boolean cacheFlag)
+ {
+ // Sets this object's ThreadPool field to be the input argument
+ sPhotoManager = photoManager;
+
+ // Gets the URL for the View
+ mImageURL = photoView.getLocation();
+
+ // Instantiates the weak reference to the incoming view
+ mImageWeakRef = new WeakReference<PhotoView>(photoView);
+
+ // Sets the cache flag to the input argument
+ mCacheEnabled = cacheFlag;
+
+ // Gets the width and height of the provided ImageView
+ mTargetWidth = photoView.getWidth();
+ mTargetHeight = photoView.getHeight();
+
+ }
+
+ // Implements HTTPDownloaderRunnable.getByteBuffer
+ @Override
+ public byte[] getByteBuffer() {
+
+ // Returns the global field
+ return mImageBuffer;
+ }
+
+ /**
+ * Recycles an PhotoTask object before it's put back into the pool. One reason to do
+ * this is to avoid memory leaks.
+ */
+ void recycle() {
+
+ // Deletes the weak reference to the imageView
+ if ( null != mImageWeakRef ) {
+ mImageWeakRef.clear();
+ mImageWeakRef = null;
+ }
+
+ // Releases references to the byte buffer and the BitMap
+ mImageBuffer = null;
+ mDecodedImage = null;
+ }
+
+ // Implements PhotoDownloadRunnable.getTargetWidth. Returns the global target width.
+ @Override
+ public int getTargetWidth() {
+ return mTargetWidth;
+ }
+
+ // Implements PhotoDownloadRunnable.getTargetHeight. Returns the global target height.
+ @Override
+ public int getTargetHeight() {
+ return mTargetHeight;
+ }
+
+ // Detects the state of caching
+ boolean isCacheEnabled() {
+ return mCacheEnabled;
+ }
+
+ // Implements PhotoDownloadRunnable.getImageURL. Returns the global Image URL.
+ @Override
+ public URL getImageURL() {
+ return mImageURL;
+ }
+
+ // Implements PhotoDownloadRunnable.setByteBuffer. Sets the image buffer to a buffer object.
+ @Override
+ public void setByteBuffer(byte[] imageBuffer) {
+ mImageBuffer = imageBuffer;
+ }
+
+ // Delegates handling the current state of the task to the PhotoManager object
+ void handleState(int state) {
+ sPhotoManager.handleState(this, state);
+ }
+
+ // Returns the image that PhotoDecodeRunnable decoded.
+ Bitmap getImage() {
+ return mDecodedImage;
+ }
+
+ // Returns the instance that downloaded the image
+ Runnable getHTTPDownloadRunnable() {
+ return mDownloadRunnable;
+ }
+
+ // Returns the instance that decode the image
+ Runnable getPhotoDecodeRunnable() {
+ return mDecodeRunnable;
+ }
+
+ // Returns the ImageView that's being constructed.
+ public PhotoView getPhotoView() {
+ if ( null != mImageWeakRef ) {
+ return mImageWeakRef.get();
+ }
+ return null;
+ }
+
+ /*
+ * Returns the Thread that this Task is running on. The method must first get a lock on a
+ * static field, in this case the ThreadPool singleton. The lock is needed because the
+ * Thread object reference is stored in the Thread object itself, and that object can be
+ * changed by processes outside of this app.
+ */
+ public Thread getCurrentThread() {
+ synchronized(sPhotoManager) {
+ return mCurrentThread;
+ }
+ }
+
+ /*
+ * Sets the identifier for the current Thread. This must be a synchronized operation; see the
+ * notes for getCurrentThread()
+ */
+ public void setCurrentThread(Thread thread) {
+ synchronized(sPhotoManager) {
+ mCurrentThread = thread;
+ }
+ }
+
+ // Implements ImageCoderRunnable.setImage(). Sets the Bitmap for the current image.
+ @Override
+ public void setImage(Bitmap decodedImage) {
+ mDecodedImage = decodedImage;
+ }
+
+ // Implements PhotoDownloadRunnable.setHTTPDownloadThread(). Calls setCurrentThread().
+ @Override
+ public void setDownloadThread(Thread currentThread) {
+ setCurrentThread(currentThread);
+ }
+
+ /*
+ * Implements PhotoDownloadRunnable.handleHTTPState(). Passes the download state to the
+ * ThreadPool object.
+ */
+
+ @Override
+ public void handleDownloadState(int state) {
+ int outState;
+
+ // Converts the download state to the overall state
+ switch(state) {
+ case PhotoDownloadRunnable.HTTP_STATE_COMPLETED:
+ outState = PhotoManager.DOWNLOAD_COMPLETE;
+ break;
+ case PhotoDownloadRunnable.HTTP_STATE_FAILED:
+ outState = PhotoManager.DOWNLOAD_FAILED;
+ break;
+ default:
+ outState = PhotoManager.DOWNLOAD_STARTED;
+ break;
+ }
+ // Passes the state to the ThreadPool object.
+ handleState(outState);
+ }
+
+ // Implements PhotoDecodeRunnable.setImageDecodeThread(). Calls setCurrentThread().
+ @Override
+ public void setImageDecodeThread(Thread currentThread) {
+ setCurrentThread(currentThread);
+ }
+
+ /*
+ * Implements PhotoDecodeRunnable.handleDecodeState(). Passes the decoding state to the
+ * ThreadPool object.
+ */
+ @Override
+ public void handleDecodeState(int state) {
+ int outState;
+
+ // Converts the decode state to the overall state.
+ switch(state) {
+ case PhotoDecodeRunnable.DECODE_STATE_COMPLETED:
+ outState = PhotoManager.TASK_COMPLETE;
+ break;
+ case PhotoDecodeRunnable.DECODE_STATE_FAILED:
+ outState = PhotoManager.DOWNLOAD_FAILED;
+ break;
+ default:
+ outState = PhotoManager.DECODE_STARTED;
+ break;
+ }
+
+ // Passes the state to the ThreadPool object.
+ handleState(outState);
+ }
+}
diff --git a/samples/training/threadsample/src/com/example/android/threadsample/PhotoThumbnailFragment.java b/samples/training/threadsample/src/com/example/android/threadsample/PhotoThumbnailFragment.java
new file mode 100644
index 0000000..0a89e9e
--- /dev/null
+++ b/samples/training/threadsample/src/com/example/android/threadsample/PhotoThumbnailFragment.java
@@ -0,0 +1,436 @@
+/*
+ * Copyright (C) 2012 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.example.android.threadsample;
+
+import android.content.Context;
+import android.content.Intent;
+import android.database.Cursor;
+import android.graphics.drawable.Drawable;
+import android.net.Uri;
+import android.os.Bundle;
+import android.support.v4.app.Fragment;
+import android.support.v4.app.FragmentTransaction;
+import android.support.v4.app.LoaderManager;
+import android.support.v4.content.CursorLoader;
+import android.support.v4.content.Loader;
+import android.support.v4.content.LocalBroadcastManager;
+import android.support.v4.widget.CursorAdapter;
+import android.util.DisplayMetrics;
+import android.view.LayoutInflater;
+import android.view.View;
+import android.view.ViewGroup;
+import android.view.ViewGroup.LayoutParams;
+import android.widget.AbsListView;
+import android.widget.AdapterView;
+import android.widget.GridView;
+
+import java.net.MalformedURLException;
+import java.net.URL;
+import java.util.concurrent.RejectedExecutionException;
+
+/**
+ * PhotoThumbnailFragment displays a GridView of picture thumbnails downloaded from Picasa
+ */
+public class PhotoThumbnailFragment extends Fragment implements
+ LoaderManager.LoaderCallbacks<Cursor>, AdapterView.OnItemClickListener {
+
+ private static final String STATE_IS_HIDDEN =
+ "com.example.android.threadsample.STATE_IS_HIDDEN";
+
+ // The width of each column in the grid
+ private int mColumnWidth;
+
+ // A Drawable for a grid cell that's empty
+ private Drawable mEmptyDrawable;
+
+ // The GridView for displaying thumbnails
+ private GridView mGridView;
+
+ // Denotes if the GridView has been loaded
+ private boolean mIsLoaded;
+
+ // Intent for starting the IntentService that downloads the Picasa featured picture RSS feed
+ private Intent mServiceIntent;
+
+ // An adapter between a Cursor and the Fragment's GridView
+ private GridViewAdapter mAdapter;
+
+ // The URL of the Picasa featured picture RSS feed, in String format
+ private static final String PICASA_RSS_URL =
+ "http://picasaweb.google.com/data/feed/base/featured?" +
+ "alt=rss&kind=photo&access=public&slabel=featured&hl=en_US&imgmax=1600";
+
+ private static final String[] PROJECTION =
+ {
+ DataProviderContract._ID,
+ DataProviderContract.IMAGE_THUMBURL_COLUMN,
+ DataProviderContract.IMAGE_URL_COLUMN
+ };
+
+ // Constants that define the order of columns in the returned cursor
+ private static final int IMAGE_THUMBURL_CURSOR_INDEX = 1;
+ private static final int IMAGE_URL_CURSOR_INDEX = 2;
+
+ // Identifies a particular Loader being used in this component
+ private static final int URL_LOADER = 0;
+
+ /*
+ * This callback is invoked when the framework is starting or re-starting the Loader. It
+ * returns a CursorLoader object containing the desired query
+ */
+ @Override
+ public Loader<Cursor> onCreateLoader(int loaderID, Bundle bundle)
+ {
+ /*
+ * Takes action based on the ID of the Loader that's being created
+ */
+ switch (loaderID) {
+ case URL_LOADER:
+ // Returns a new CursorLoader
+ return new CursorLoader(
+ getActivity(), // Context
+ DataProviderContract.PICTUREURL_TABLE_CONTENTURI, // Table to query
+ PROJECTION, // Projection to return
+ null, // No selection clause
+ null, // No selection arguments
+ null // Default sort order
+ );
+ default:
+ // An invalid id was passed in
+ return null;
+
+ }
+
+ }
+
+ /*
+ * This callback is invoked when the the Fragment's View is being loaded. It sets up the View.
+ */
+ @Override
+ public View onCreateView(LayoutInflater inflater, ViewGroup viewGroup, Bundle bundle) {
+
+ // Always call the super method first
+ super.onCreateView(inflater, viewGroup, bundle);
+
+ /*
+ * Inflates the View from the gridlist layout file, using the layout parameters in
+ * "viewGroup"
+ */
+ View localView = inflater.inflate(R.layout.gridlist, viewGroup, false);
+
+ // Sets the View's data adapter to be a new GridViewAdapter
+ mAdapter = new GridViewAdapter(getActivity());
+
+ // Gets a handle to the GridView in the layout
+ mGridView = ((GridView) localView.findViewById(android.R.id.list));
+
+ // Instantiates a DisplayMetrics object
+ DisplayMetrics localDisplayMetrics = new DisplayMetrics();
+
+ // Gets the current display metrics from the current Window
+ getActivity().getWindowManager().getDefaultDisplay().getMetrics(localDisplayMetrics);
+
+ /*
+ * Gets the dp value from the thumbSize resource as an integer in dps. The value can
+ * be adjusted for specific display sizes, etc. in the dimens.xml file for a particular
+ * values-<qualifier> directory
+ */
+ int pixelSize = getResources().getDimensionPixelSize(R.dimen.thumbSize);
+
+ /*
+ * Calculates a width scale factor from the pixel width of the current display and the
+ * desired pixel size
+ */
+ int widthScale = localDisplayMetrics.widthPixels / pixelSize;
+
+ // Calculates the grid column width
+ mColumnWidth = (localDisplayMetrics.widthPixels / widthScale);
+
+ // Sets the GridView's column width
+ mGridView.setColumnWidth(mColumnWidth);
+
+ // Starts by setting the GridView to have no columns
+ mGridView.setNumColumns(-1);
+
+ // Sets the GridView's data adapter
+ mGridView.setAdapter(mAdapter);
+
+ /*
+ * Sets the GridView's click listener to be this class. As a result, when users click the
+ * GridView, PhotoThumbnailFragment.onClick() is invoked.
+ */
+ mGridView.setOnItemClickListener(this);
+
+ /*
+ * Sets the "empty" View for the layout. If there's nothing to show, a ProgressBar
+ * is displayed.
+ */
+ mGridView.setEmptyView(localView.findViewById(R.id.progressRoot));
+
+ // Sets a dark background to show when no image is queued to be downloaded
+ mEmptyDrawable = getResources().getDrawable(R.drawable.imagenotqueued);
+
+ // Initializes the CursorLoader
+ getLoaderManager().initLoader(URL_LOADER, null, this);
+
+ /*
+ * Creates a new Intent to send to the download IntentService. The Intent contains the
+ * URL of the Picasa feature picture RSS feed
+ */
+ mServiceIntent =
+ new Intent(getActivity(), RSSPullService.class)
+ .setData(Uri.parse(PICASA_RSS_URL));
+
+ // If there's no pre-existing state for this Fragment
+ if (bundle == null) {
+ // If the data wasn't previously loaded
+ if (!this.mIsLoaded) {
+ // Starts the IntentService to download the RSS feed data
+ getActivity().startService(mServiceIntent);
+ }
+
+ // If this Fragment existed previously, gets its state
+ } else if (bundle.getBoolean(STATE_IS_HIDDEN, false)) {
+
+ // Begins a transaction
+ FragmentTransaction localFragmentTransaction =
+ getFragmentManager().beginTransaction();
+
+ // Hides the Fragment
+ localFragmentTransaction.hide(this);
+
+ // Commits the transaction
+ localFragmentTransaction.commit();
+ }
+
+ // Returns the View inflated from the layout
+ return localView;
+ }
+
+ /*
+ * This callback is invoked when the Fragment is being destroyed.
+ */
+ @Override
+ public void onDestroyView() {
+
+ // Sets variables to null, to avoid memory leaks
+ mGridView = null;
+
+ // If the EmptyDrawable contains something, sets those members to null
+ if (mEmptyDrawable != null) {
+ this.mEmptyDrawable.setCallback(null);
+ this.mEmptyDrawable = null;
+ }
+
+ // Always call the super method last
+ super.onDestroyView();
+ }
+
+ /*
+ * This callback is invoked after onDestroyView(). It clears out variables, shuts down the
+ * CursorLoader, and so forth
+ */
+ @Override
+ public void onDetach() {
+
+ // Destroys variables and references, and catches Exceptions
+ try {
+ getLoaderManager().destroyLoader(0);
+ if (mAdapter != null) {
+ mAdapter.changeCursor(null);
+ mAdapter = null;
+ }
+ } catch (Throwable localThrowable) {
+ }
+
+ // Always call the super method last
+ super.onDetach();
+ return;
+ }
+
+ /*
+ * This is invoked whenever the visibility state of the Fragment changes
+ */
+ @Override
+ public void onHiddenChanged(boolean viewState) {
+ super.onHiddenChanged(viewState);
+ }
+
+ /*
+ * Implements OnItemClickListener.onItemClick() for this View's listener.
+ * This implementation detects the View that was clicked and retrieves its picture URL.
+ */
+ @Override
+ public void onItemClick(AdapterView<?> adapterView, View view, int viewId, long rowId) {
+
+ // Returns a one-row cursor for the data that backs the View that was clicked.
+ Cursor cursor = (Cursor) mAdapter.getItem(viewId);
+
+ // Retrieves the urlString from the cursor
+ String urlString = cursor.getString(IMAGE_URL_CURSOR_INDEX);
+
+ /*
+ * Creates a new Intent to get the full picture for the thumbnail that the user clicked.
+ * The full photo is loaded into a separate Fragment
+ */
+ Intent localIntent =
+ new Intent(Constants.ACTION_VIEW_IMAGE)
+ .setData(Uri.parse(urlString));
+
+ // Broadcasts the Intent to receivers in this app. See DisplayActivity.FragmentDisplayer.
+ LocalBroadcastManager.getInstance(getActivity()).sendBroadcast(localIntent);
+ }
+
+ /*
+ * Invoked when the CursorLoader finishes the query. A reference to the Loader and the
+ * returned Cursor are passed in as arguments
+ */
+ @Override
+ public void onLoadFinished(Loader<Cursor> loader, Cursor returnCursor) {
+
+ /*
+ * Changes the adapter's Cursor to be the results of the load. This forces the View to
+ * redraw.
+ */
+
+ mAdapter.changeCursor(returnCursor);
+ }
+
+ /*
+ * Invoked when the CursorLoader is being reset. For example, this is called if the
+ * data in the provider changes and the Cursor becomes stale.
+ */
+ @Override
+ public void onLoaderReset(Loader<Cursor> loader) {
+
+ // Sets the Adapter's backing data to null. This prevents memory leaks.
+ mAdapter.changeCursor(null);
+ }
+
+ /*
+ * This callback is invoked when the system has to destroy the Fragment for some reason. It
+ * allows the Fragment to save its state, so the state can be restored later on.
+ */
+ @Override
+ public void onSaveInstanceState(Bundle bundle) {
+
+ // Saves the show-hide status of the display
+ bundle.putBoolean(STATE_IS_HIDDEN, isHidden());
+
+ // Always call the super method last
+ super.onSaveInstanceState(bundle);
+ }
+
+ // Sets the state of the loaded flag
+ public void setLoaded(boolean loadState) {
+ mIsLoaded = loadState;
+ }
+
+ /**
+ * Defines a custom View adapter that extends CursorAdapter. The main reason to do this is to
+ * display images based on the backing Cursor, rather than just displaying the URLs that the
+ * Cursor contains.
+ */
+ private class GridViewAdapter extends CursorAdapter {
+
+ /**
+ * Simplified constructor that calls the super constructor with the input Context,
+ * a null value for Cursor, and no flags
+ * @param context A Context for this object
+ */
+ public GridViewAdapter(Context context) {
+ super(context, null, false);
+ }
+
+ /**
+ *
+ * Binds a View and a Cursor
+ *
+ * @param view An existing View object
+ * @param context A Context for the View and Cursor
+ * @param cursor The Cursor to bind to the View, representing one row of the returned query.
+ */
+ @Override
+ public void bindView(View view, Context context, Cursor cursor) {
+
+ // Gets a handle to the View
+ PhotoView localImageDownloaderView = (PhotoView) view.getTag();
+
+ // Converts the URL string to a URL and tries to retrieve the picture
+ try {
+ // Gets the URL
+ URL localURL =
+ new URL(
+ cursor.getString(IMAGE_THUMBURL_CURSOR_INDEX)
+ )
+ ;
+ /*
+ * Invokes setImageURL for the View. If the image isn't already available, this
+ * will download and decode it.
+ */
+ localImageDownloaderView.setImageURL(
+ localURL, true, PhotoThumbnailFragment.this.mEmptyDrawable);
+
+ // Catches an invalid URL
+ } catch (MalformedURLException localMalformedURLException) {
+ localMalformedURLException.printStackTrace();
+
+ // Catches errors trying to download and decode the picture in a ThreadPool
+ } catch (RejectedExecutionException localRejectedExecutionException) {
+ }
+ }
+
+ /**
+ * Creates a new View that shows the contents of the Cursor
+ *
+ *
+ * @param context A Context for the View and Cursor
+ * @param cursor The Cursor to display. This is a single row of the returned query
+ * @param viewGroup The viewGroup that's the parent of the new View
+ * @return the newly-created View
+ */
+ @Override
+ public View newView(Context context, Cursor cursor, ViewGroup viewGroup) {
+ // Gets a new layout inflater instance
+ LayoutInflater inflater = LayoutInflater.from(context);
+
+ /*
+ * Creates a new View by inflating the specified layout file. The root ViewGroup is
+ * the root of the layout file. This View is a FrameLayout
+ */
+ View layoutView = inflater.inflate(R.layout.galleryitem, null);
+
+ /*
+ * Creates a second View to hold the thumbnail image.
+ */
+ View thumbView = layoutView.findViewById(R.id.thumbImage);
+
+ /*
+ * Sets layout parameters for the layout based on the layout parameters of a virtual
+ * list. In addition, this sets the layoutView's width to be MATCH_PARENT, and its
+ * height to be the column width?
+ */
+ layoutView.setLayoutParams(new AbsListView.LayoutParams(LayoutParams.MATCH_PARENT,
+ PhotoThumbnailFragment.this.mColumnWidth));
+
+ // Sets the layoutView's tag to be the same as the thumbnail image tag.
+ layoutView.setTag(thumbView);
+ return layoutView;
+ }
+
+ }
+}
diff --git a/samples/training/threadsample/src/com/example/android/threadsample/PhotoView.java b/samples/training/threadsample/src/com/example/android/threadsample/PhotoView.java
new file mode 100644
index 0000000..eaf3940
--- /dev/null
+++ b/samples/training/threadsample/src/com/example/android/threadsample/PhotoView.java
@@ -0,0 +1,349 @@
+/*
+ * Copyright (C) 2012 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.example.android.threadsample;
+
+import android.content.Context;
+import android.content.res.TypedArray;
+import android.graphics.Bitmap;
+import android.graphics.Canvas;
+import android.graphics.drawable.Drawable;
+import android.net.Uri;
+import android.util.AttributeSet;
+import android.view.View;
+import android.widget.ImageView;
+
+
+import java.lang.ref.WeakReference;
+import java.net.URL;
+
+/**
+ * This class extends the standard Android ImageView View class with some features
+ * that are useful for downloading, decoding, and displaying Picasa images.
+ *
+ */
+public class PhotoView extends ImageView {
+
+ // Indicates if caching should be used
+ private boolean mCacheFlag;
+
+ // Status flag that indicates if onDraw has completed
+ private boolean mIsDrawn;
+
+ /*
+ * Creates a weak reference to the ImageView in this object. The weak
+ * reference prevents memory leaks and crashes, because it automatically tracks the "state" of
+ * the variable it backs. If the reference becomes invalid, the weak reference is garbage-
+ * collected.
+ * This technique is important for referring to objects that are part of a component lifecycle.
+ * Using a hard reference may cause memory leaks as the value continues to change; even worse,
+ * it can cause crashes if the underlying component is destroyed. Using a weak reference to
+ * a View ensures that the reference is more transitory in nature.
+ */
+ private WeakReference<View> mThisView;
+
+ // Contains the ID of the internal View
+ private int mHideShowResId = -1;
+
+ // The URL that points to the source of the image for this ImageView
+ private URL mImageURL;
+
+ // The Thread that will be used to download the image for this ImageView
+ private PhotoTask mDownloadThread;
+
+ /**
+ * Creates an ImageDownloadView with no settings
+ * @param context A context for the View
+ */
+ public PhotoView(Context context) {
+ super(context);
+ }
+
+ /**
+ * Creates an ImageDownloadView and gets attribute values
+ * @param context A Context to use with the View
+ * @param attributeSet The entire set of attributes for the View
+ */
+ public PhotoView(Context context, AttributeSet attributeSet) {
+ super(context, attributeSet);
+
+ // Gets attributes associated with the attribute set
+ getAttributes(attributeSet);
+ }
+
+ /**
+ * Creates an ImageDownloadView, gets attribute values, and applies a default style
+ * @param context A context for the View
+ * @param attributeSet The entire set of attributes for the View
+ * @param defaultStyle The default style to use with the View
+ */
+ public PhotoView(Context context, AttributeSet attributeSet, int defaultStyle) {
+ super(context, attributeSet, defaultStyle);
+
+ // Gets attributes associated with the attribute set
+ getAttributes(attributeSet);
+ }
+
+ /**
+ * Gets the resource ID for the hideShowSibling resource
+ * @param attributeSet The entire set of attributes for the View
+ */
+ private void getAttributes(AttributeSet attributeSet) {
+
+ // Gets an array of attributes for the View
+ TypedArray attributes =
+ getContext().obtainStyledAttributes(attributeSet, R.styleable.ImageDownloaderView);
+
+ // Gets the resource Id of the View to hide or show
+ mHideShowResId =
+ attributes.getResourceId(R.styleable.ImageDownloaderView_hideShowSibling, -1);
+
+ // Returns the array for re-use
+ attributes.recycle();
+ }
+
+ /**
+ * Sets the visibility of the PhotoView
+ * @param visState The visibility state (see View.setVisibility)
+ */
+ private void showView(int visState) {
+ // If the View contains something
+ if (mThisView != null) {
+
+ // Gets a local hard reference to the View
+ View localView = mThisView.get();
+
+ // If the weak reference actually contains something, set the visibility
+ if (localView != null)
+ localView.setVisibility(visState);
+ }
+ }
+
+ /**
+ * Sets the image in this ImageView to null, and makes the View visible
+ */
+ public void clearImage() {
+ setImageDrawable(null);
+ showView(View.VISIBLE);
+ }
+
+ /**
+ * Returns the URL of the picture associated with this ImageView
+ * @return a URL
+ */
+ final URL getLocation() {
+ return mImageURL;
+ }
+
+ /*
+ * This callback is invoked when the system attaches the ImageView to a Window. The callback
+ * is invoked before onDraw(), but may be invoked after onMeasure()
+ */
+ @Override
+ protected void onAttachedToWindow() {
+ // Always call the supermethod first
+ super.onAttachedToWindow();
+
+ // If the sibling View is set and the parent of the ImageView is itself a View
+ if ((this.mHideShowResId != -1) && ((getParent() instanceof View))) {
+
+ // Gets a handle to the sibling View
+ View localView = ((View) getParent()).findViewById(this.mHideShowResId);
+
+ // If the sibling View contains something, make it the weak reference for this View
+ if (localView != null) {
+ this.mThisView = new WeakReference<View>(localView);
+ }
+ }
+ }
+
+ /*
+ * This callback is invoked when the ImageView is removed from a Window. It "unsets" variables
+ * to prevent memory leaks.
+ */
+ @Override
+ protected void onDetachedFromWindow() {
+
+ // Clears out the image drawable, turns off the cache, disconnects the view from a URL
+ setImageURL(null, false, null);
+
+ // Gets the current Drawable, or null if no Drawable is attached
+ Drawable localDrawable = getDrawable();
+
+ // if the Drawable is null, unbind it from this VIew
+ if (localDrawable != null)
+ localDrawable.setCallback(null);
+
+ // If this View still exists, clears the weak reference, then sets the reference to null
+ if (mThisView != null) {
+ mThisView.clear();
+ mThisView = null;
+ }
+
+ // Sets the downloader thread to null
+ this.mDownloadThread = null;
+
+ // Always call the super method last
+ super.onDetachedFromWindow();
+ }
+
+ /*
+ * This callback is invoked when the system tells the View to draw itself. If the View isn't
+ * already drawn, and its URL isn't null, it invokes a Thread to download the image. Otherwise,
+ * it simply passes the existing Canvas to the super method
+ */
+ @Override
+ protected void onDraw(Canvas canvas) {
+ // If the image isn't already drawn, and the URL is set
+ if ((!mIsDrawn) && (mImageURL != null)) {
+
+ // Starts downloading this View, using the current cache setting
+ mDownloadThread = PhotoManager.startDownload(this, mCacheFlag);
+
+ // After successfully downloading the image, this marks that it's available.
+ mIsDrawn = true;
+ }
+ // Always call the super method last
+ super.onDraw(canvas);
+ }
+
+ /**
+ * Sets the current View weak reference to be the incoming View. See the definition of
+ * mThisView
+ * @param view the View to use as the new WeakReference
+ */
+ public void setHideView(View view) {
+ this.mThisView = new WeakReference<View>(view);
+ }
+
+ @Override
+ public void setImageBitmap(Bitmap paramBitmap) {
+ super.setImageBitmap(paramBitmap);
+ }
+
+ @Override
+ public void setImageDrawable(Drawable drawable) {
+ // The visibility of the View
+ int viewState;
+
+ /*
+ * Sets the View state to visible if the method is called with a null argument (the
+ * image is being cleared). Otherwise, sets the View state to invisible before refreshing
+ * it.
+ */
+ if (drawable == null) {
+
+ viewState = View.VISIBLE;
+ } else {
+
+ viewState = View.INVISIBLE;
+ }
+ // Either hides or shows the View, depending on the view state
+ showView(viewState);
+
+ // Invokes the supermethod with the provided drawable
+ super.setImageDrawable(drawable);
+ }
+
+ /*
+ * Displays a drawable in the View
+ */
+ @Override
+ public void setImageResource(int resId) {
+ super.setImageResource(resId);
+ }
+
+ /*
+ * Sets the URI for the Image
+ */
+ @Override
+ public void setImageURI(Uri uri) {
+ super.setImageURI(uri);
+ }
+
+ /**
+ * Attempts to set the picture URL for this ImageView and then download the picture.
+ * <p>
+ * If the picture URL for this view is already set, and the input URL is not the same as the
+ * stored URL, then the picture has moved and any existing downloads are stopped.
+ * <p>
+ * If the input URL is the same as the stored URL, then nothing needs to be done.
+ * <p>
+ * If the stored URL is null, then this method starts a download and decode of the picture
+ * @param pictureURL An incoming URL for a Picasa picture
+ * @param cacheFlag Whether to use caching when doing downloading and decoding
+ * @param imageDrawable The Drawable to use for this ImageView
+ */
+ public void setImageURL(URL pictureURL, boolean cacheFlag, Drawable imageDrawable) {
+ // If the picture URL for this ImageView is already set
+ if (mImageURL != null) {
+
+ // If the stored URL doesn't match the incoming URL, then the picture has changed.
+ if (!mImageURL.equals(pictureURL)) {
+
+ // Stops any ongoing downloads for this ImageView
+ PhotoManager.removeDownload(mDownloadThread, mImageURL);
+ } else {
+
+ // The stored URL matches the incoming URL. Returns without doing any work.
+ return;
+ }
+ }
+
+ // Sets the Drawable for this ImageView
+ setImageDrawable(imageDrawable);
+
+ // Stores the picture URL for this ImageView
+ mImageURL = pictureURL;
+
+ // If the draw operation for this ImageVIew has completed, and the picture URL isn't empty
+ if ((mIsDrawn) && (pictureURL != null)) {
+
+ // Sets the cache flag
+ mCacheFlag = cacheFlag;
+
+ /*
+ * Starts a download of the picture file. Notice that if caching is on, the picture
+ * file's contents may be taken from the cache.
+ */
+ mDownloadThread = PhotoManager.startDownload(this, cacheFlag);
+ }
+ }
+
+ /**
+ * Sets the Drawable for this ImageView
+ * @param drawable A Drawable to use for the ImageView
+ */
+ public void setStatusDrawable(Drawable drawable) {
+
+ // If the View is empty, sets a Drawable as its content
+ if (mThisView == null) {
+ setImageDrawable(drawable);
+ }
+ }
+
+ /**
+ * Sets the content of this ImageView to be a Drawable resource
+ * @param resId
+ */
+ public void setStatusResource(int resId) {
+
+ // If the View is empty, provides it with a Drawable resource as its content
+ if (mThisView == null) {
+ setImageResource(resId);
+ }
+ }
+}
diff --git a/samples/training/threadsample/src/com/example/android/threadsample/ProgressNotifier.java b/samples/training/threadsample/src/com/example/android/threadsample/ProgressNotifier.java
new file mode 100644
index 0000000..479ba79
--- /dev/null
+++ b/samples/training/threadsample/src/com/example/android/threadsample/ProgressNotifier.java
@@ -0,0 +1,21 @@
+/*
+ * Copyright (C) 2012 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.example.android.threadsample;
+
+public interface ProgressNotifier {
+ public void notifyProgress(String paramString);
+}
diff --git a/samples/training/threadsample/src/com/example/android/threadsample/RSSPullParser.java b/samples/training/threadsample/src/com/example/android/threadsample/RSSPullParser.java
new file mode 100644
index 0000000..48b2151
--- /dev/null
+++ b/samples/training/threadsample/src/com/example/android/threadsample/RSSPullParser.java
@@ -0,0 +1,204 @@
+/*
+ * Copyright (C) 2012 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.example.android.threadsample;
+
+import org.xml.sax.helpers.DefaultHandler;
+import org.xmlpull.v1.XmlPullParser;
+import org.xmlpull.v1.XmlPullParserException;
+import org.xmlpull.v1.XmlPullParserFactory;
+
+import android.content.ContentValues;
+import android.net.Uri;
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.util.Vector;
+
+/**
+ * RSSPullParser reads an RSS feed from the Picasa featured pictures site. It uses
+ * several packages from the widely-known XMLPull API.
+ *
+ */
+public class RSSPullParser extends DefaultHandler {
+ // Global constants
+
+ // An attribute value indicating that the element contains media content
+ private static final String CONTENT = "media:content";
+
+ // An attribute value indicating that the element contains a thumbnail
+ private static final String THUMBNAIL = "media:thumbnail";
+
+ // An attribute value indicating that the element contains an item
+ private static final String ITEM = "item";
+
+ // Sets the initial size of the vector that stores data.
+ private static final int VECTOR_INITIAL_SIZE = 500;
+
+ // Storage for a single ContentValues for image data
+ private static ContentValues mImage;
+
+ // A vector that will contain all of the images
+ private Vector<ContentValues> mImages;
+
+ /**
+ * A getter that returns the image data Vector
+ * @return A Vector containing all of the image data retrieved by the parser
+ */
+ public Vector<ContentValues> getImages() {
+ return mImages;
+ }
+ /**
+ * This method parses XML in an input stream and stores parts of the data in memory
+ *
+ * @param inputStream a stream of data containing XML elements, usually a RSS feed
+ * @param progressNotifier a helper class for sending status and logs
+ * @throws XmlPullParserException defined by XMLPullParser; thrown if the thread is cancelled.
+ * @throws IOException thrown if an IO error occurs during parsing
+ */
+ public void parseXml(InputStream inputStream,
+ BroadcastNotifier progressNotifier)
+ throws XmlPullParserException, IOException {
+
+ // Instantiates a parser factory
+ XmlPullParserFactory localXmlPullParserFactory = XmlPullParserFactory
+ .newInstance();
+
+ // Turns off namespace handling for the XML input
+ localXmlPullParserFactory.setNamespaceAware(false);
+
+ // Instantiates a new pull parser
+ XmlPullParser localXmlPullParser = localXmlPullParserFactory
+ .newPullParser();
+
+ // Sets the parser's input stream
+ localXmlPullParser.setInput(inputStream, null);
+
+ // Gets the first event in the input sream
+ int eventType = localXmlPullParser.getEventType();
+
+ // Sets the number of images read to 1
+ int imageCount = 1;
+
+ // Returns if the current event (state) is not START_DOCUMENT
+ if (eventType != XmlPullParser.START_DOCUMENT) {
+
+ throw new XmlPullParserException("Invalid RSS");
+
+ }
+
+ // Creates a new store for image URL data
+ mImages = new Vector<ContentValues>(VECTOR_INITIAL_SIZE);
+
+ // Loops indefinitely. The exit occurs if there are no more URLs to process
+ while (true) {
+
+ // Gets the next event in the input stream
+ int nextEvent = localXmlPullParser.next();
+
+ // If the current thread is interrupted, throws an exception and returns
+ if (Thread.currentThread().isInterrupted()) {
+
+ throw new XmlPullParserException("Cancelled");
+
+ // At the end of the feed, exits the loop
+ } else if (nextEvent == XmlPullParser.END_DOCUMENT) {
+ break;
+
+ // At the beginning of the feed, skips the event and continues
+ } else if (nextEvent == XmlPullParser.START_DOCUMENT) {
+ continue;
+
+ // At the start of a tag, gets the tag's name
+ } else if (nextEvent == XmlPullParser.START_TAG) {
+ String eventName = localXmlPullParser.getName();
+
+ /*
+ * If this is the start of an individual item, logs it and creates a new
+ * ContentValues
+ */
+ if (eventName.equalsIgnoreCase(ITEM)) {
+
+ mImage = new ContentValues();
+
+ // If this isn't an item, then checks for other options
+ } else {
+
+ // Defines keys to store the column names
+ String imageUrlKey;
+ String imageNameKey;
+
+ // Defines a place to store the filename of a URL,
+ String fileName;
+
+ // If it's CONTENT
+ if (eventName.equalsIgnoreCase(CONTENT)) {
+
+ // Stores the image URL and image name column names as keys
+ imageUrlKey = DataProviderContract.IMAGE_URL_COLUMN;
+ imageNameKey = DataProviderContract.IMAGE_PICTURENAME_COLUMN;
+
+ // If it's a THUMBNAIL
+ } else if (eventName.equalsIgnoreCase(THUMBNAIL)) {
+
+ // Stores the thumbnail URL and thumbnail name column names as keys
+ imageUrlKey = DataProviderContract.IMAGE_THUMBURL_COLUMN;
+ imageNameKey = DataProviderContract.IMAGE_THUMBNAME_COLUMN;
+
+ // Otherwise it's some other event that isn't important
+ } else {
+ continue;
+ }
+
+ // It's not an ITEM. Gets the URL attribute from the event
+ String urlValue = localXmlPullParser.getAttributeValue(null, "url");
+
+ // If the value is null, exits
+ if (urlValue == null)
+ break;
+
+ // Puts the URL and the key into the ContentValues
+ mImage.put(imageUrlKey, urlValue);
+
+ // Gets the filename of the URL and puts it into the ContentValues
+ fileName = Uri.parse(urlValue).getLastPathSegment();
+ mImage.put(imageNameKey, fileName);
+ }
+ }
+ /*
+ * If it's not an ITEM, and it is an END_TAG, and the current event is an ITEM, and
+ * there is data in the current ContentValues
+ */
+ else if ((nextEvent == XmlPullParser.END_TAG)
+ && (localXmlPullParser.getName().equalsIgnoreCase(ITEM))
+ && (mImage != null)) {
+
+ // Adds the current ContentValues to the ContentValues storage
+ mImages.add(mImage);
+
+ // Logs progress
+ progressNotifier.notifyProgress("Parsed Image[" + imageCount + "]:"
+ + mImage.getAsString(DataProviderContract.IMAGE_URL_COLUMN));
+
+ // Clears out the current ContentValues
+ mImage = null;
+
+ // Increments the count of the number of images stored.
+ imageCount++;
+ }
+ }
+ }
+}
diff --git a/samples/training/threadsample/src/com/example/android/threadsample/RSSPullService.java b/samples/training/threadsample/src/com/example/android/threadsample/RSSPullService.java
new file mode 100644
index 0000000..b8b3e26
--- /dev/null
+++ b/samples/training/threadsample/src/com/example/android/threadsample/RSSPullService.java
@@ -0,0 +1,266 @@
+/*
+ * Copyright (C) 2012 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.example.android.threadsample;
+
+import android.app.IntentService;
+import android.content.ContentValues;
+import android.content.Intent;
+import android.database.Cursor;
+
+import org.apache.http.HttpStatus;
+import org.xmlpull.v1.XmlPullParserException;
+
+import java.io.IOException;
+import java.net.HttpURLConnection;
+import java.net.MalformedURLException;
+import java.net.URL;
+import java.net.URLConnection;
+import java.util.Date;
+import java.util.Vector;
+
+/**
+ * This service pulls RSS content from a web site URL contained in the incoming Intent (see
+ * onHandleIntent()). As it runs, it broadcasts its status using LocalBroadcastManager; any
+ * component that wants to see the status should implement a subclass of BroadcastReceiver and
+ * register to receive broadcast Intents with category = CATEGORY_DEFAULT and action
+ * Constants.BROADCAST_ACTION.
+ *
+ */
+public class RSSPullService extends IntentService {
+ // Used to write to the system log from this class.
+ public static final String LOG_TAG = "RSSPullService";
+
+ // Defines and instantiates an object for handling status updates.
+ private BroadcastNotifier mBroadcaster = new BroadcastNotifier(this);
+
+ /**
+ * An IntentService must always have a constructor that calls the super constructor. The
+ * string supplied to the super constructor is used to give a name to the IntentService's
+ * background thread.
+ */
+ public RSSPullService() {
+
+ super("RSSPullService");
+ }
+
+ /**
+ * In an IntentService, onHandleIntent is run on a background thread. As it
+ * runs, it broadcasts its current status using the LocalBroadcastManager.
+ * @param workIntent The Intent that starts the IntentService. This Intent contains the
+ * URL of the web site from which the RSS parser gets data.
+ */
+ @Override
+ protected void onHandleIntent(Intent workIntent) {
+ // Gets a URL to read from the incoming Intent's "data" value
+ String localUrlString = workIntent.getDataString();
+
+ // Creates a projection to use in querying the modification date table in the provider.
+ final String[] dateProjection = new String[]
+ {
+ DataProviderContract.ROW_ID,
+ DataProviderContract.DATA_DATE_COLUMN
+ };
+
+ // A URL that's local to this method
+ URL localURL;
+
+ // A cursor that's local to this method.
+ Cursor cursor = null;
+
+ /*
+ * A block that tries to connect to the Picasa featured picture URL passed as the "data"
+ * value in the incoming Intent. The block throws exceptions (see the end of the block).
+ */
+ try {
+
+ // Convert the incoming data string to a URL.
+ localURL = new URL(localUrlString);
+
+ /*
+ * Tries to open a connection to the URL. If an IO error occurs, this throws an
+ * IOException
+ */
+ URLConnection localURLConnection = localURL.openConnection();
+
+ // If the connection is an HTTP connection, continue
+ if ((localURLConnection instanceof HttpURLConnection)) {
+
+ // Broadcasts an Intent indicating that processing has started.
+ mBroadcaster.broadcastIntentWithState(Constants.STATE_ACTION_STARTED);
+
+ // Casts the connection to a HTTP connection
+ HttpURLConnection localHttpURLConnection = (HttpURLConnection) localURLConnection;
+
+ // Sets the user agent for this request.
+ localHttpURLConnection.setRequestProperty("User-Agent", Constants.USER_AGENT);
+
+ /*
+ * Queries the content provider to see if this URL was read previously, and when.
+ * The content provider throws an exception if the URI is invalid.
+ */
+ cursor = getContentResolver().query(
+ DataProviderContract.DATE_TABLE_CONTENTURI,
+ dateProjection,
+ null,
+ null,
+ null);
+
+ // Flag to indicate that new metadata was retrieved
+ boolean newMetadataRetrieved;
+
+ /*
+ * Tests to see if the table contains a modification date for the URL
+ */
+ if (null != cursor && cursor.moveToFirst()) {
+
+ // Find the URL's last modified date in the content provider
+ long storedModifiedDate =
+ cursor.getLong(cursor.getColumnIndex(
+ DataProviderContract.DATA_DATE_COLUMN)
+ )
+ ;
+
+ /*
+ * If the modified date isn't 0, sets another request property to ensure that
+ * data is only downloaded if it has changed since the last recorded
+ * modification date. Formats the date according to the RFC1123 format.
+ */
+ if (0 != storedModifiedDate) {
+ localHttpURLConnection.setRequestProperty(
+ "If-Modified-Since",
+ org.apache.http.impl.cookie.DateUtils.formatDate(
+ new Date(storedModifiedDate),
+ org.apache.http.impl.cookie.DateUtils.PATTERN_RFC1123));
+ }
+
+ // Marks that new metadata does not need to be retrieved
+ newMetadataRetrieved = false;
+
+ } else {
+
+ /*
+ * No modification date was found for the URL, so newmetadata has to be
+ * retrieved.
+ */
+ newMetadataRetrieved = true;
+
+ }
+
+ // Reports that the service is about to connect to the RSS feed
+ mBroadcaster.broadcastIntentWithState(Constants.STATE_ACTION_CONNECTING);
+
+ // Gets a response code from the RSS server
+ int responseCode = localHttpURLConnection.getResponseCode();
+
+ switch (responseCode) {
+
+ // If the response is OK
+ case HttpStatus.SC_OK:
+
+ // Gets the last modified data for the URL
+ long lastModifiedDate = localHttpURLConnection.getLastModified();
+
+ // Reports that the service is parsing
+ mBroadcaster.broadcastIntentWithState(Constants.STATE_ACTION_PARSING);
+
+ /*
+ * Instantiates a pull parser and uses it to parse XML from the RSS feed.
+ * The mBroadcaster argument send a broadcaster utility object to the
+ * parser.
+ */
+ RSSPullParser localPicasaPullParser = new RSSPullParser();
+
+ localPicasaPullParser.parseXml(
+ localURLConnection.getInputStream(),
+ mBroadcaster);
+
+ // Reports that the service is now writing data to the content provider.
+ mBroadcaster.broadcastIntentWithState(Constants.STATE_ACTION_WRITING);
+
+ // Gets image data from the parser
+ Vector<ContentValues> imageValues = localPicasaPullParser.getImages();
+
+ // Stores the number of images
+ int imageVectorSize = imageValues.size();
+
+ // Creates one ContentValues for each image
+ ContentValues[] imageValuesArray = new ContentValues[imageVectorSize];
+
+ imageValuesArray = imageValues.toArray(imageValuesArray);
+
+ /*
+ * Stores the image data in the content provider. The content provider
+ * throws an exception if the URI is invalid.
+ */
+ getContentResolver().bulkInsert(
+ DataProviderContract.PICTUREURL_TABLE_CONTENTURI, imageValuesArray);
+
+ // Creates another ContentValues for storing date information
+ ContentValues dateValues = new ContentValues();
+
+ // Adds the URL's last modified date to the ContentValues
+ dateValues.put(DataProviderContract.DATA_DATE_COLUMN, lastModifiedDate);
+
+ if (newMetadataRetrieved) {
+
+ // No previous metadata existed, so insert the data
+ getContentResolver().insert(
+ DataProviderContract.DATE_TABLE_CONTENTURI,
+ dateValues
+ );
+
+ } else {
+
+ // Previous metadata existed, so update it.
+ getContentResolver().update(
+ DataProviderContract.DATE_TABLE_CONTENTURI,
+ dateValues,
+ DataProviderContract.ROW_ID + "=" +
+ cursor.getString(cursor.getColumnIndex(
+ DataProviderContract.ROW_ID)), null);
+ }
+ break;
+
+ }
+
+ // Reports that the feed retrieval is complete.
+ mBroadcaster.broadcastIntentWithState(Constants.STATE_ACTION_COMPLETE);
+ }
+
+ // Handles possible exceptions
+ } catch (MalformedURLException localMalformedURLException) {
+
+ localMalformedURLException.printStackTrace();
+
+ } catch (IOException localIOException) {
+
+ localIOException.printStackTrace();
+
+ } catch (XmlPullParserException localXmlPullParserException) {
+
+ localXmlPullParserException.printStackTrace();
+
+ } finally {
+
+ // If an exception occurred, close the cursor to prevent memory leaks.
+ if (null != cursor) {
+ cursor.close();
+ }
+ }
+ }
+
+}
