AboutBliss: Add Split Tab for Bliss
- Added changelog from
Crdroid:https://github.com/crdroidandroid/android_packages_apps_crDroidSettings/commit/7840d021c05e8e479cd8bbd5d6b17cba91eb9f75#diff-2663c16d236900067dc79b88c86e1924
- Credits to koush for UrlImageViewHelper
Signed-off-by: starkdroid <gamerprince.exp@gmail.com>
@Jackeagle edit: build within settings app
- Remove unwanted drawables
- Move Bliss Version , build date from Settings
- Move Bliss Share.
- Add BlissOTA
Signed-off-by: Jackeagle <jackeagle102@gmail.com>
diff --git a/res/drawable-hdpi/ic_null.png b/res/drawable-hdpi/ic_null.png
new file mode 100644
index 0000000..f4bc042
--- /dev/null
+++ b/res/drawable-hdpi/ic_null.png
Binary files differ
diff --git a/res/drawable-mdpi/ic_null.png b/res/drawable-mdpi/ic_null.png
new file mode 100644
index 0000000..f536636
--- /dev/null
+++ b/res/drawable-mdpi/ic_null.png
Binary files differ
diff --git a/res/layout/dev_card.xml b/res/layout/dev_card.xml
new file mode 100644
index 0000000..4b43b41
--- /dev/null
+++ b/res/layout/dev_card.xml
@@ -0,0 +1,87 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+/**
+ * Copyright (c) 2013, The Android Open Kang 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_width="wrap_content"
+ android:layout_height="wrap_content"
+ android:paddingLeft="15dip"
+ android:paddingRight="15dip">
+
+ <RelativeLayout
+ android:id="@+id/image_here"
+ android:layout_width="wrap_content"
+ android:layout_height="150dip"
+ android:paddingTop="8dip"
+ android:gravity="center_vertical"
+ android:orientation="vertical">
+
+ <ImageView
+ android:id="@+id/photo"
+ android:layout_width="match_parent"
+ android:layout_height="150dip"
+ android:scaleType="centerCrop"/>
+
+ <View
+ android:id="@+id/photo_text_bar"
+ android:layout_width="wrap_content"
+ android:layout_height="42dip"
+ android:layout_alignBottom="@id/photo"
+ android:layout_alignLeft="@id/photo"
+ android:background="#7F000000"/>
+
+ <LinearLayout
+ android:layout_width="wrap_content"
+ android:layout_height="42dip"
+ android:layout_alignBottom="@id/photo"
+ android:layout_alignLeft="@id/photo"
+ android:gravity="center_vertical">
+
+ <TextView
+ android:id="@+id/name"
+ android:layout_width="wrap_content"
+ android:layout_height="wrap_content"
+ android:layout_marginLeft="8dip"
+ android:singleLine="true"
+ android:ellipsize="end"
+ android:textColor="@android:color/white"
+ android:textAppearance="?android:attr/textAppearanceMedium"/>
+
+ <ImageView
+ android:id="@+id/gplus_button"
+ android:layout_width="wrap_content"
+ android:layout_height="wrap_content"
+ android:layout_marginLeft="8dip"
+ android:scaleType="centerInside"/>
+
+ </LinearLayout>
+
+ <ImageView
+ android:id="@+id/github_button"
+ android:layout_width="wrap_content"
+ android:layout_height="wrap_content"
+ android:layout_alignBottom="@id/photo"
+ android:layout_alignParentRight="true"
+ android:paddingRight="4dip"
+ android:paddingBottom="4dp"
+ android:layout_toRightOf="@+id/gplus_button"
+ android:scaleType="centerInside" />
+
+ </RelativeLayout>
+
+</FrameLayout>
diff --git a/res/layout/image_list_preference.xml b/res/layout/image_list_preference.xml
new file mode 100644
index 0000000..270e9d9
--- /dev/null
+++ b/res/layout/image_list_preference.xml
@@ -0,0 +1,33 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+/**
+ * Copyright (c) 2013, The Android Open Kang 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 xmlns:android="http://schemas.android.com/apk/res/android"
+ android:layout_width="fill_parent"
+ android:layout_height="wrap_content"
+ android:paddingBottom="12dp"
+ android:paddingLeft="6dp"
+ android:paddingRight="6dp"
+ android:paddingTop="12dp" >
+
+ <ImageView
+ android:id="@+id/image"
+ android:layout_width="wrap_content"
+ android:layout_height="wrap_content"
+ android:adjustViewBounds="true" />
+
+</LinearLayout>
diff --git a/res/layout/summary_image_preference.xml b/res/layout/summary_image_preference.xml
new file mode 100644
index 0000000..08784e6
--- /dev/null
+++ b/res/layout/summary_image_preference.xml
@@ -0,0 +1,73 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+/**
+ * Copyright (c) 2013, The Android Open Kang 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 xmlns:android="http://schemas.android.com/apk/res/android"
+ android:layout_width="match_parent"
+ android:layout_height="wrap_content"
+ android:gravity="center_vertical"
+ android:minHeight="?android:attr/listPreferredItemHeight"
+ android:paddingLeft="6dp"
+ android:paddingRight="6dp" >
+
+ <LinearLayout
+ android:layout_width="wrap_content"
+ android:layout_height="match_parent"
+ android:gravity="center"
+ android:orientation="horizontal" >
+
+ <ImageView
+ android:id="@+android:id/icon"
+ android:layout_width="wrap_content"
+ android:layout_height="wrap_content"
+ android:layout_gravity="center"
+ android:minWidth="48dp"
+ android:paddingRight="6dp" />
+ </LinearLayout>
+
+ <RelativeLayout
+ android:layout_width="fill_parent"
+ android:layout_height="wrap_content"
+ android:layout_weight="1"
+ android:paddingBottom="6dip"
+ android:paddingRight="6dp"
+ android:paddingTop="6dip" >
+
+ <TextView
+ android:id="@+android:id/title"
+ android:layout_width="wrap_content"
+ android:layout_height="wrap_content"
+ android:ellipsize="marquee"
+ android:fadingEdge="horizontal"
+ android:singleLine="true"
+ android:textAppearance="?android:attr/textAppearanceMedium" />
+
+ <LinearLayout
+ android:layout_width="fill_parent"
+ android:layout_height="60dp"
+ android:layout_alignLeft="@android:id/title"
+ android:layout_below="@android:id/title" >
+
+ <ImageView
+ android:id="@+id/summary_image"
+ android:layout_width="fill_parent"
+ android:layout_height="wrap_content"
+ android:layout_gravity="center" />
+ </LinearLayout>
+ </RelativeLayout>
+
+</LinearLayout>
diff --git a/res/values/bliss_attrs.xml b/res/values/bliss_attrs.xml
new file mode 100644
index 0000000..7d85594
--- /dev/null
+++ b/res/values/bliss_attrs.xml
@@ -0,0 +1,31 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!-- Copyright (C) 2015 BlissRoms 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.
+-->
+<resources xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+
+ <!-- About Bliss -->
+ <declare-styleable name="DeveloperPreference">
+ <attr name="gplusHandle" format="string" />
+ <attr name="nameDev" format="string"/>
+ <attr name="githubLink" format="string" />
+ <attr name="emailDev" format="string" />
+ </declare-styleable>
+
+ <declare-styleable name="ImageListPreference">
+ <attr name="summaryImage" format="reference" />
+ <attr name="entryImages" format="reference" />
+ </declare-styleable>
+
+</resources>
diff --git a/res/values/bliss_strings.xml b/res/values/bliss_strings.xml
index 9c93747..cb3ad20 100644
--- a/res/values/bliss_strings.xml
+++ b/res/values/bliss_strings.xml
@@ -17,5 +17,30 @@
<!-- About Bliss -->
<string name="about_bliss_title">Bliss</string>
+ <string name="about_phone_title">Phone</string>
+ <string name="share_bliss_title">Share BlissRoms</string>
+ <string name="share_bliss_summary">Let everyone know you are a Bliss</string>
+ <string name="share_message">get to know about #BlissRoms @ https://plus.google.com/communities/118265887490106132524</string>
+ <string name="share_chooser_title">Share BlissRoms</string>
+ <string name="bliss_source_title">Github</string>
+ <string name="bliss_source_summary">Build bliss for any device</string>
+ <string name="bliss_google_plus_title">Google</string>
+ <string name="bliss_google_plus_summary">Visit our G page for support and news</string>
+ <string name="team_bliss_title">Teambliss</string>
+ <string name="bliss_telegram_title">Telegram</string>
+ <string name="bliss_telegram_summary">Get Updates on News and Device builds via telegram</string>
+
+ <!-- Bliss version -->
+ <string name="bliss_version">Bliss version</string>
+ <string name="bliss_version_default">Unknown</string>
+
+ <!-- Bliss build date -->
+ <string name="build_date">Bliss build date</string>
+ <string name="build_date_default">2014-01-01-0000</string>
+
+ <!-- Changelog -->
+ <string name="changelog_bliss_title">Changelog</string>
+ <string name="changelog_bliss_error">Unable to load changelog</string>
+ <string name="changelog_summary">Quick peek on an update</string>
</resources>
diff --git a/res/xml/about_bliss.xml b/res/xml/about_bliss.xml
index 0f736f8..d0166f4 100644
--- a/res/xml/about_bliss.xml
+++ b/res/xml/about_bliss.xml
@@ -16,5 +16,59 @@
<PreferenceScreen xmlns:android="http://schemas.android.com/apk/res/android"
xmlns:settings="http://schemas.android.com/apk/res/com.android.settings"
android:title="@string/about_bliss_title" >
+ <PreferenceScreen android:layout="@layout/bliss_logo_row" android:key="bliss_logo" />
+
+ <!-- BlissRoms OTA -->
+ <PreferenceScreen
+ android:key="bliss_ota"
+ android:title="@string/bliss_ota">
+ <intent
+ android:action="android.intent.action.MAIN"
+ android:targetPackage="blissroms.updates"
+ android:targetClass="blissroms.updates.activities.MainActivity" />
+ </PreferenceScreen>
+
+ <!-- Bliss version -->
+ <Preference android:key="bliss_version"
+ style="?android:preferenceInformationStyle"
+ android:title="@string/bliss_version"
+ android:summary="@string/bliss_version_default" />
+
+ <!-- Bliss build date -->
+ <Preference android:key="build_date"
+ style="?android:preferenceInformationStyle"
+ android:title="@string/build_date"
+ android:summary="@string/build_date_default" />
+
+ <!-- Changelog -->
+ <PreferenceScreen
+ android:key="changelog"
+ android:title="@string/changelog_bliss_title"
+ android:fragment="com.blissroms.about.Changelog"
+ android:summary="@string/changelog_summary" />
+
+ <!-- Bliss Share -->
+ <PreferenceScreen
+ android:key="share"
+ android:title="@string/share_bliss_title"
+ android:summary="@string/share_bliss_summary" />
+
+ <!-- Bliss Github -->
+ <PreferenceScreen
+ android:key="bliss_source"
+ android:title="@string/bliss_source_title"
+ android:summary="@string/bliss_source_summary" />
+
+ <!-- Bliss Telegram -->
+ <PreferenceScreen
+ android:key="bliss_telegram"
+ android:title="@string/bliss_telegram_title"
+ android:summary="@string/bliss_telegram_summary" />
+
+ <!-- Bliss GooglePlus -->
+ <PreferenceScreen
+ android:key="bliss_google_plus"
+ android:title="@string/bliss_google_plus_title"
+ android:summary="@string/bliss_google_plus_summary" />
</PreferenceScreen>
diff --git a/src/com/blissroms/About.java b/src/com/blissroms/BlissInfoSettings.java
similarity index 93%
rename from src/com/blissroms/About.java
rename to src/com/blissroms/BlissInfoSettings.java
index 5368cb3..10b6d12 100644
--- a/src/com/blissroms/About.java
+++ b/src/com/blissroms/BlissInfoSettings.java
@@ -34,6 +34,7 @@
import android.view.ViewGroup;
import com.android.settings.DeviceInfoSettings;
import com.blissroms.blissify.PagerSlidingTabStrip;
+import com.blissroms.about.AboutBliss;
import com.android.settings.R;
import com.android.settings.Utils;
import com.android.settings.SettingsPreferenceFragment;
@@ -43,7 +44,7 @@
import java.util.ArrayList;
import java.util.List;
-public class About extends SettingsPreferenceFragment {
+public class BlissInfoSettings extends SettingsPreferenceFragment {
ViewPager mViewPager;
String titleString[];
@@ -56,7 +57,7 @@
mContainer = container;
final ActionBar actionBar = getActivity().getActionBar();
- View view = inflater.inflate(R.layout.additional_settings, container, false);
+ View view = inflater.inflate(R.layout.blissify_ui, container, false);
mViewPager = (ViewPager) view.findViewById(R.id.pager);
mTabs = (PagerSlidingTabStrip) view.findViewById(R.id.tabs);
@@ -116,7 +117,7 @@
private String[] getTitles() {
String titleString[];
titleString = new String[]{
- getString(R.string.about_settings),
+ getString(R.string.about_phone_title),
getString(R.string.about_bliss_title)};
return titleString;
}
diff --git a/src/com/blissroms/about/AboutBliss.java b/src/com/blissroms/about/AboutBliss.java
index 8ddf55d..d003d73 100644
--- a/src/com/blissroms/about/AboutBliss.java
+++ b/src/com/blissroms/about/AboutBliss.java
@@ -16,11 +16,14 @@
package com.blissroms.about;
+import android.app.Activity;
import android.os.Bundle;
+import android.net.Uri;
+import android.os.Build;
import android.support.v7.preference.Preference;
import android.support.v7.preference.PreferenceScreen;
import android.provider.Settings;
-
+import android.content.Intent;
import com.android.settings.Utils;
import android.os.SystemProperties;
import com.android.settings.R;
@@ -34,17 +37,64 @@
public class AboutBliss extends SettingsPreferenceFragment {
+ private static final String KEY_MOD_BUILD_DATE = "build_date";
+ private static final String KEY_BLISS_VERSION = "bliss_version";
+ private static final String KEY_BLISS_SHARE = "share";
+
+ Preference mSourceUrl;
+ Preference mGoogleUrl;
+ Preference mTelegramUrl;
+
+
@Override
- public void onCreate(Bundle savedInstanceState) {
- super.onCreate(savedInstanceState);
+ public void onCreate(Bundle icicle) {
+ super.onCreate(icicle);
+
addPreferencesFromResource(R.xml.about_bliss);
+
+ setValueSummary(KEY_MOD_BUILD_DATE, "ro.build.date");
+ setValueSummary(KEY_BLISS_VERSION, "ro.bliss.version");
+ findPreference(KEY_BLISS_VERSION).setEnabled(true);
+ mSourceUrl = findPreference("bliss_source");
+ mTelegramUrl = findPreference("bliss_telegram");
+ mGoogleUrl = findPreference("bliss_google_plus");
+ }
+
+ private void setValueSummary(String preference, String property) {
+ try {
+ findPreference(preference).setSummary(
+ SystemProperties.get(property,
+ getResources().getString(R.string.device_info_default)));
+ } catch (RuntimeException e) {
+ // No recovery
+ }
}
@Override
- public boolean onPreferenceChange(Preference preference, Object objValue) {
- return false;
+ public boolean onPreferenceTreeClick(Preference preference) {
+ if (preference == mSourceUrl) {
+ launchUrl("https://github.com/BlissRoms");
+ } else if (preference == mTelegramUrl) {
+ launchUrl("");
+ } else if (preference == mGoogleUrl) {
+ launchUrl("https://plus.google.com/communities/118265887490106132524");
+ } else if (preference.getKey().equals(KEY_BLISS_SHARE)) {
+ Intent intent = new Intent();
+ intent.setAction(Intent.ACTION_SEND);
+ intent.setType("text/plain");
+ intent.putExtra(Intent.EXTRA_TEXT, String.format(
+ getActivity().getString(R.string.share_message), Build.MODEL));
+ startActivity(Intent.createChooser(intent, getActivity().getString(R.string.share_chooser_title)));
+ }
+ return super.onPreferenceTreeClick(preference);
}
+ private void launchUrl(String url) {
+ Uri uriUrl = Uri.parse(url);
+ Intent intent = new Intent(Intent.ACTION_VIEW, uriUrl);
+ getActivity().startActivity(intent);
+}
+
@Override
protected int getMetricsCategory() {
return MetricsEvent.ABOUT_BLISS;
diff --git a/src/com/blissroms/about/Changelog.java b/src/com/blissroms/about/Changelog.java
new file mode 100644
index 0000000..313cf64
--- /dev/null
+++ b/src/com/blissroms/about/Changelog.java
@@ -0,0 +1,71 @@
+/*
+ * Copyright (C) 2016 crDroid Android
+ *
+ * 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.blissroms.about;
+
+import android.app.Fragment;
+import android.os.Bundle;
+import android.view.LayoutInflater;
+import android.view.View;
+import android.view.ViewGroup;
+import android.widget.ScrollView;
+import android.widget.TextView;
+
+import com.android.settings.R;
+
+import java.io.FileReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+
+public class Changelog extends Fragment {
+
+ private static final String CHANGELOG_PATH = "/system/etc/Changelog.txt";
+
+ @Override
+ public View onCreateView(LayoutInflater inflater, ViewGroup container,
+ Bundle savedInstanceState) {
+ InputStreamReader inputReader = null;
+ String text = null;
+
+ try {
+ StringBuilder data = new StringBuilder();
+ char tmp[] = new char[2048];
+ int numRead;
+
+ inputReader = new FileReader(CHANGELOG_PATH);
+ while ((numRead = inputReader.read(tmp)) >= 0) {
+ data.append(tmp, 0, numRead);
+ }
+ text = data.toString();
+ } catch (IOException e) {
+ text = getString(R.string.changelog_bliss_error);
+ } finally {
+ try {
+ if (inputReader != null) {
+ inputReader.close();
+ }
+ } catch (IOException e) {
+ }
+ }
+
+ final TextView textView = new TextView(getActivity());
+ textView.setText(text);
+
+ final ScrollView scrollView = new ScrollView(getActivity());
+ scrollView.addView(textView);
+
+ return scrollView;
+ }
+}
diff --git a/src/com/blissroms/widget/DeveloperPreference.java b/src/com/blissroms/widget/DeveloperPreference.java
new file mode 100644
index 0000000..8f21f99
--- /dev/null
+++ b/src/com/blissroms/widget/DeveloperPreference.java
@@ -0,0 +1,164 @@
+package com.blissroms.widget;
+
+import android.content.Context;
+import android.content.Intent;
+import android.content.res.TypedArray;
+import android.graphics.Bitmap;
+import android.graphics.Point;
+import android.graphics.BitmapFactory;
+import android.graphics.drawable.BitmapDrawable;
+import android.graphics.drawable.Drawable;
+import android.net.Uri;
+import android.net.http.AndroidHttpClient;
+import android.os.AsyncTask;
+import android.preference.Preference;
+import android.util.AttributeSet;
+import android.util.Log;
+import android.view.View;
+import android.view.Display;
+import android.view.View.OnClickListener;
+import android.view.ViewGroup;
+import android.view.WindowManager;
+import android.widget.ImageView;
+import android.widget.TextView;
+
+import com.android.settings.R;
+import com.koushikdutta.urlimageviewhelper.UrlImageViewCallback;
+import com.koushikdutta.urlimageviewhelper.UrlImageViewHelper;
+
+import java.io.InputStream;
+import java.net.HttpURLConnection;
+import org.apache.http.HttpEntity;
+import org.apache.http.HttpResponse;
+import org.apache.http.client.methods.HttpGet;
+import org.apache.http.client.params.HttpClientParams;
+import org.apache.http.params.BasicHttpParams;
+import org.apache.http.params.HttpParams;
+import java.security.MessageDigest;
+import java.security.NoSuchAlgorithmException;
+public class DeveloperPreference extends Preference {
+
+ private static final String TAG = "DeveloperPreference";
+ public static final String GRAVATAR_API = "http://www.gravatar.com/avatar/";
+ public static int mDefaultAvatarSize = 250;
+ private ImageView gplusButton;
+ private ImageView githubButton;
+ private ImageView photoView;
+
+ private TextView devName;
+
+ private String nameDev;
+ private String gplusName;
+ private String githubLink;
+ private String devEmail;
+ private final Display mDisplay;
+
+ public DeveloperPreference(Context context, AttributeSet attrs) {
+ super(context, attrs);
+
+ TypedArray typedArray = null;
+ try {
+ typedArray = context.obtainStyledAttributes(attrs, R.styleable.DeveloperPreference);
+ nameDev = typedArray.getString(R.styleable.DeveloperPreference_nameDev);
+ gplusName = typedArray.getString(R.styleable.DeveloperPreference_gplusHandle);
+ githubLink = typedArray.getString(R.styleable.DeveloperPreference_githubLink);
+ devEmail = typedArray.getString(R.styleable.DeveloperPreference_emailDev);
+ } finally {
+ if (typedArray != null) {
+ typedArray.recycle();
+ }
+ }
+ WindowManager wm = (WindowManager) getContext().getSystemService(Context.WINDOW_SERVICE);
+ mDisplay = wm.getDefaultDisplay();
+ }
+
+ @Override
+ protected View onCreateView(ViewGroup parent) {
+ super.onCreateView(parent);
+
+ View layout = View.inflate(getContext(), R.layout.dev_card, null);
+
+ gplusButton = (ImageView) layout.findViewById(R.id.gplus_button);
+ githubButton = (ImageView) layout.findViewById(R.id.github_button);
+ devName = (TextView) layout.findViewById(R.id.name);
+ photoView = (ImageView) layout.findViewById(R.id.photo);
+
+ return layout;
+ }
+
+ @Override
+ protected void onBindView(View view) {
+ super.onBindView(view);
+
+ if (githubLink != null) {
+ final OnClickListener openGithub = new OnClickListener() {
+ @Override
+ public void onClick(View v) {
+ Uri githubURL = Uri.parse(githubLink);
+ final Intent intent = new Intent(Intent.ACTION_VIEW, githubURL);
+ intent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK | Intent.FLAG_ACTIVITY_CLEAR_TOP);
+ getContext().startActivity(intent);
+ }
+ };
+ githubButton.setOnClickListener(openGithub);
+ } else {
+ githubButton.setVisibility(View.GONE);
+ }
+
+
+ final OnPreferenceClickListener openGplus = new OnPreferenceClickListener() {
+ @Override
+ public boolean onPreferenceClick(Preference preference) {
+
+ if (gplusName != null) {
+
+ Uri gplusURL = Uri.parse("https://plus.google.com/+" + gplusName);
+ final Intent intent = new Intent(Intent.ACTION_VIEW, gplusURL);
+ intent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK | Intent.FLAG_ACTIVITY_CLEAR_TOP);
+ getContext().startActivity(intent);
+
+ }
+
+ return true;
+ }
+ };
+
+ this.setOnPreferenceClickListener(openGplus);
+ UrlImageViewHelper.setUrlDrawable(this.photoView,
+ getGravatarUrl(devEmail),
+ R.drawable.ic_null,
+ UrlImageViewHelper.CACHE_DURATION_ONE_WEEK);
+
+ if (gplusName == null)
+ gplusButton.setVisibility(View.INVISIBLE);
+
+
+ devName.setText(nameDev);
+
+ }
+
+ public String getGravatarUrl(String email) {
+ try {
+ Point point = new Point();
+ mDisplay.getSize(point);
+ mDefaultAvatarSize = point.x;
+ String emailMd5 = getMd5(email.trim().toLowerCase());
+ return String.format("%s%s?s=%d",
+ GRAVATAR_API,
+ emailMd5,
+ mDefaultAvatarSize);
+ } catch (NoSuchAlgorithmException e) {
+ return null;
+ }
+ }
+
+ private String getMd5(String devEmail) throws NoSuchAlgorithmException {
+ MessageDigest md = MessageDigest.getInstance("MD5");
+ md.update(devEmail.getBytes());
+ byte byteData[] = md.digest();
+ StringBuffer sb = new StringBuffer();
+ for (int i = 0; i < byteData.length; i++)
+ sb.append(Integer.toString((byteData[i] & 0xff) + 0x100, 16).substring(1));
+ return sb.toString();
+ }
+}
diff --git a/src/com/koushikdutta/urlimageviewhelper/Constants.java b/src/com/koushikdutta/urlimageviewhelper/Constants.java
new file mode 100644
index 0000000..d96ef60
--- /dev/null
+++ b/src/com/koushikdutta/urlimageviewhelper/Constants.java
@@ -0,0 +1,11 @@
+package com.koushikdutta.urlimageviewhelper;
+
+public interface Constants {
+
+ public static final String LOGTAG = "UrlImageViewHelper";
+
+ public static final boolean LOG_ENABLED = false; //set to True to enable verbose logging
+
+ //set here and not in Build to maintain proper backwards compatibility
+ public static final int HONEYCOMB = 11;
+}
diff --git a/src/com/koushikdutta/urlimageviewhelper/DiskLruCache.java b/src/com/koushikdutta/urlimageviewhelper/DiskLruCache.java
new file mode 100644
index 0000000..dd2c2fb
--- /dev/null
+++ b/src/com/koushikdutta/urlimageviewhelper/DiskLruCache.java
@@ -0,0 +1,930 @@
+/*
+ * Copyright (C) 2011 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.koushikdutta.urlimageviewhelper;
+
+import java.io.BufferedInputStream;
+import java.io.BufferedWriter;
+import java.io.Closeable;
+import java.io.EOFException;
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.FileNotFoundException;
+import java.io.FileOutputStream;
+import java.io.FileWriter;
+import java.io.FilterOutputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.InputStreamReader;
+import java.io.OutputStream;
+import java.io.OutputStreamWriter;
+import java.io.Reader;
+import java.io.StringWriter;
+import java.io.Writer;
+import java.lang.reflect.Array;
+import java.nio.charset.Charset;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Iterator;
+import java.util.LinkedHashMap;
+import java.util.Map;
+import java.util.concurrent.Callable;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.LinkedBlockingQueue;
+import java.util.concurrent.ThreadPoolExecutor;
+import java.util.concurrent.TimeUnit;
+
+/**
+ * A cache that uses a bounded amount of space on a filesystem. Each cache
+ * entry has a string key and a fixed number of values. Values are byte
+ * sequences, accessible as streams or files. Each value must be between {@code
+ * 0} and {@code Integer.MAX_VALUE} bytes in length.
+ *
+ * <p>The cache stores its data in a directory on the filesystem. This
+ * directory must be exclusive to the cache; the cache may delete or overwrite
+ * files from its directory. It is an error for multiple processes to use the
+ * same cache directory at the same time.
+ *
+ * <p>This cache limits the number of bytes that it will store on the
+ * filesystem. When the number of stored bytes exceeds the limit, the cache will
+ * remove entries in the background until the limit is satisfied. The limit is
+ * not strict: the cache may temporarily exceed it while waiting for files to be
+ * deleted. The limit does not include filesystem overhead or the cache
+ * journal so space-sensitive applications should set a conservative limit.
+ *
+ * <p>Clients call {@link #edit} to create or update the values of an entry. An
+ * entry may have only one editor at one time; if a value is not available to be
+ * edited then {@link #edit} will return null.
+ * <ul>
+ * <li>When an entry is being <strong>created</strong> it is necessary to
+ * supply a full set of values; the empty value should be used as a
+ * placeholder if necessary.
+ * <li>When an entry is being <strong>edited</strong>, it is not necessary
+ * to supply data for every value; values default to their previous
+ * value.
+ * </ul>
+ * Every {@link #edit} call must be matched by a call to {@link Editor#commit}
+ * or {@link Editor#abort}. Committing is atomic: a read observes the full set
+ * of values as they were before or after the commit, but never a mix of values.
+ *
+ * <p>Clients call {@link #get} to read a snapshot of an entry. The read will
+ * observe the value at the time that {@link #get} was called. Updates and
+ * removals after the call do not impact ongoing reads.
+ *
+ * <p>This class is tolerant of some I/O errors. If files are missing from the
+ * filesystem, the corresponding entries will be dropped from the cache. If
+ * an error occurs while writing a cache value, the edit will fail silently.
+ * Callers should handle other problems by catching {@code IOException} and
+ * responding appropriately.
+ */
+public final class DiskLruCache implements Closeable {
+ static final String JOURNAL_FILE = "journal";
+ static final String JOURNAL_FILE_TMP = "journal.tmp";
+ static final String MAGIC = "libcore.io.DiskLruCache";
+ static final String VERSION_1 = "1";
+ static final long ANY_SEQUENCE_NUMBER = -1;
+ private static final String CLEAN = "CLEAN";
+ private static final String DIRTY = "DIRTY";
+ private static final String REMOVE = "REMOVE";
+ private static final String READ = "READ";
+
+ /* XXX From java.util.Arrays */
+ @SuppressWarnings("unchecked")
+ private static <T> T[] copyOfRange(T[] original, int start, int end) {
+ int originalLength = original.length; // For exception priority compatibility.
+ if (start > end) {
+ throw new IllegalArgumentException();
+ }
+ if (start < 0 || start > originalLength) {
+ throw new ArrayIndexOutOfBoundsException();
+ }
+ int resultLength = end - start;
+ int copyLength = Math.min(resultLength, originalLength - start);
+ T[] result = (T[]) Array.newInstance(original.getClass().getComponentType(), resultLength);
+ System.arraycopy(original, start, result, 0, copyLength);
+ return result;
+ }
+
+ /* XXX From java.nio.charset.Charsets */
+ private static final Charset UTF_8 = Charset.forName("UTF-8");
+
+ /* XXX From libcore.io.IoUtils */
+ private static void deleteContents(File dir) throws IOException {
+ File[] files = dir.listFiles();
+ if (files == null) {
+ throw new IllegalArgumentException("not a directory: " + dir);
+ }
+ for (File file : files) {
+ if (file.isDirectory()) {
+ deleteContents(file);
+ }
+ if (!file.delete()) {
+ throw new IOException("failed to delete file: " + file);
+ }
+ }
+ }
+
+ /* XXX From libcore.io.IoUtils */
+ private static void closeQuietly(/*Auto*/Closeable closeable) {
+ if (closeable != null) {
+ try {
+ closeable.close();
+ } catch (RuntimeException rethrown) {
+ throw rethrown;
+ } catch (Exception ignored) {
+ }
+ }
+ }
+
+ /* XXX From libcore.io.Streams */
+ private static String readFully(Reader reader) throws IOException {
+ try {
+ StringWriter writer = new StringWriter();
+ char[] buffer = new char[1024];
+ int count;
+ while ((count = reader.read(buffer)) != -1) {
+ writer.write(buffer, 0, count);
+ }
+ return writer.toString();
+ } finally {
+ reader.close();
+ }
+ }
+
+ /* XXX From libcore.io.Streams */
+ private static String readAsciiLine(InputStream in) throws IOException {
+ // TODO: support UTF-8 here instead
+
+ StringBuilder result = new StringBuilder(80);
+ while (true) {
+ int c = in.read();
+ if (c == -1) {
+ throw new EOFException();
+ } else if (c == '\n') {
+ break;
+ }
+
+ result.append((char) c);
+ }
+ int length = result.length();
+ if (length > 0 && result.charAt(length - 1) == '\r') {
+ result.setLength(length - 1);
+ }
+ return result.toString();
+ }
+
+ /*
+ * This cache uses a journal file named "journal". A typical journal file
+ * looks like this:
+ * libcore.io.DiskLruCache
+ * 1
+ * 100
+ * 2
+ *
+ * CLEAN 3400330d1dfc7f3f7f4b8d4d803dfcf6 832 21054
+ * DIRTY 335c4c6028171cfddfbaae1a9c313c52
+ * CLEAN 335c4c6028171cfddfbaae1a9c313c52 3934 2342
+ * REMOVE 335c4c6028171cfddfbaae1a9c313c52
+ * DIRTY 1ab96a171faeeee38496d8b330771a7a
+ * CLEAN 1ab96a171faeeee38496d8b330771a7a 1600 234
+ * READ 335c4c6028171cfddfbaae1a9c313c52
+ * READ 3400330d1dfc7f3f7f4b8d4d803dfcf6
+ *
+ * The first five lines of the journal form its header. They are the
+ * constant string "libcore.io.DiskLruCache", the disk cache's version,
+ * the application's version, the value count, and a blank line.
+ *
+ * Each of the subsequent lines in the file is a record of the state of a
+ * cache entry. Each line contains space-separated values: a state, a key,
+ * and optional state-specific values.
+ * o DIRTY lines track that an entry is actively being created or updated.
+ * Every successful DIRTY action should be followed by a CLEAN or REMOVE
+ * action. DIRTY lines without a matching CLEAN or REMOVE indicate that
+ * temporary files may need to be deleted.
+ * o CLEAN lines track a cache entry that has been successfully published
+ * and may be read. A publish line is followed by the lengths of each of
+ * its values.
+ * o READ lines track accesses for LRU.
+ * o REMOVE lines track entries that have been deleted.
+ *
+ * The journal file is appended to as cache operations occur. The journal may
+ * occasionally be compacted by dropping redundant lines. A temporary file named
+ * "journal.tmp" will be used during compaction; that file should be deleted if
+ * it exists when the cache is opened.
+ */
+
+ private final File directory;
+ private final File journalFile;
+ private final File journalFileTmp;
+ private final int appVersion;
+ private final long maxSize;
+ private final int valueCount;
+ private long size = 0;
+ private Writer journalWriter;
+ private final LinkedHashMap<String, Entry> lruEntries
+ = new LinkedHashMap<String, Entry>(0, 0.75f, true);
+ private int redundantOpCount;
+
+ /**
+ * To differentiate between old and current snapshots, each entry is given
+ * a sequence number each time an edit is committed. A snapshot is stale if
+ * its sequence number is not equal to its entry's sequence number.
+ */
+ private long nextSequenceNumber = 0;
+
+ /** This cache uses a single background thread to evict entries. */
+ private final ExecutorService executorService = new ThreadPoolExecutor(0, 1,
+ 60L, TimeUnit.SECONDS, new LinkedBlockingQueue<Runnable>());
+ private final Callable<Void> cleanupCallable = new Callable<Void>() {
+ @Override public Void call() throws Exception {
+ synchronized (DiskLruCache.this) {
+ if (journalWriter == null) {
+ return null; // closed
+ }
+ trimToSize();
+ if (journalRebuildRequired()) {
+ rebuildJournal();
+ redundantOpCount = 0;
+ }
+ }
+ return null;
+ }
+ };
+
+ private DiskLruCache(File directory, int appVersion, int valueCount, long maxSize) {
+ this.directory = directory;
+ this.appVersion = appVersion;
+ this.journalFile = new File(directory, JOURNAL_FILE);
+ this.journalFileTmp = new File(directory, JOURNAL_FILE_TMP);
+ this.valueCount = valueCount;
+ this.maxSize = maxSize;
+ }
+
+ /**
+ * Opens the cache in {@code directory}, creating a cache if none exists
+ * there.
+ *
+ * @param directory a writable directory
+ * @param appVersion
+ * @param valueCount the number of values per cache entry. Must be positive.
+ * @param maxSize the maximum number of bytes this cache should use to store
+ * @throws IOException if reading or writing the cache directory fails
+ */
+ public static DiskLruCache open(File directory, int appVersion, int valueCount, long maxSize)
+ throws IOException {
+ if (maxSize <= 0) {
+ throw new IllegalArgumentException("maxSize <= 0");
+ }
+ if (valueCount <= 0) {
+ throw new IllegalArgumentException("valueCount <= 0");
+ }
+
+ // prefer to pick up where we left off
+ DiskLruCache cache = new DiskLruCache(directory, appVersion, valueCount, maxSize);
+ if (cache.journalFile.exists()) {
+ try {
+ cache.readJournal();
+ cache.processJournal();
+ cache.journalWriter = new BufferedWriter(new FileWriter(cache.journalFile, true));
+ return cache;
+ } catch (IOException journalIsCorrupt) {
+ System.out.println("DiskLruCache " + directory + " is corrupt: "
+ + journalIsCorrupt.getMessage() + ", removing");
+ cache.delete();
+ }
+ }
+
+ // create a new empty cache
+ directory.mkdirs();
+ cache = new DiskLruCache(directory, appVersion, valueCount, maxSize);
+ cache.rebuildJournal();
+ return cache;
+ }
+
+ private void readJournal() throws IOException {
+ InputStream in = new BufferedInputStream(new FileInputStream(journalFile));
+ try {
+ String magic = /*Streams.*/readAsciiLine(in);
+ String version = /*Streams.*/readAsciiLine(in);
+ String appVersionString = /*Streams.*/readAsciiLine(in);
+ String valueCountString = /*Streams.*/readAsciiLine(in);
+ String blank = /*Streams.*/readAsciiLine(in);
+ if (!MAGIC.equals(magic)
+ || !VERSION_1.equals(version)
+ || !Integer.toString(appVersion).equals(appVersionString)
+ || !Integer.toString(valueCount).equals(valueCountString)
+ || !"".equals(blank)) {
+ throw new IOException("unexpected journal header: ["
+ + magic + ", " + version + ", " + valueCountString + ", " + blank + "]");
+ }
+
+ while (true) {
+ try {
+ readJournalLine(/*Streams.*/readAsciiLine(in));
+ } catch (EOFException endOfJournal) {
+ break;
+ }
+ }
+ } finally {
+ /*IoUtils.*/closeQuietly(in);
+ }
+ }
+
+ private void readJournalLine(String line) throws IOException {
+ String[] parts = line.split(" ");
+ if (parts.length < 2) {
+ throw new IOException("unexpected journal line: " + line);
+ }
+
+ String key = parts[1];
+ if (parts[0].equals(REMOVE) && parts.length == 2) {
+ lruEntries.remove(key);
+ return;
+ }
+
+ Entry entry = lruEntries.get(key);
+ if (entry == null) {
+ entry = new Entry(key);
+ lruEntries.put(key, entry);
+ }
+
+ if (parts[0].equals(CLEAN) && parts.length == 2 + valueCount) {
+ entry.readable = true;
+ entry.currentEditor = null;
+ entry.setLengths(/*Arrays.*/copyOfRange(parts, 2, parts.length));
+ } else if (parts[0].equals(DIRTY) && parts.length == 2) {
+ entry.currentEditor = new Editor(entry);
+ } else if (parts[0].equals(READ) && parts.length == 2) {
+ // this work was already done by calling lruEntries.get()
+ } else {
+ throw new IOException("unexpected journal line: " + line);
+ }
+ }
+
+ /**
+ * Computes the initial size and collects garbage as a part of opening the
+ * cache. Dirty entries are assumed to be inconsistent and will be deleted.
+ */
+ private void processJournal() throws IOException {
+ deleteIfExists(journalFileTmp);
+ for (Iterator<Entry> i = lruEntries.values().iterator(); i.hasNext(); ) {
+ Entry entry = i.next();
+ if (entry.currentEditor == null) {
+ for (int t = 0; t < valueCount; t++) {
+ size += entry.lengths[t];
+ }
+ } else {
+ entry.currentEditor = null;
+ for (int t = 0; t < valueCount; t++) {
+ deleteIfExists(entry.getCleanFile(t));
+ deleteIfExists(entry.getDirtyFile(t));
+ }
+ i.remove();
+ }
+ }
+ }
+
+ /**
+ * Creates a new journal that omits redundant information. This replaces the
+ * current journal if it exists.
+ */
+ private synchronized void rebuildJournal() throws IOException {
+ if (journalWriter != null) {
+ journalWriter.close();
+ }
+
+ Writer writer = new BufferedWriter(new FileWriter(journalFileTmp));
+ writer.write(MAGIC);
+ writer.write("\n");
+ writer.write(VERSION_1);
+ writer.write("\n");
+ writer.write(Integer.toString(appVersion));
+ writer.write("\n");
+ writer.write(Integer.toString(valueCount));
+ writer.write("\n");
+ writer.write("\n");
+
+ for (Entry entry : lruEntries.values()) {
+ if (entry.currentEditor != null) {
+ writer.write(DIRTY + ' ' + entry.key + '\n');
+ } else {
+ writer.write(CLEAN + ' ' + entry.key + entry.getLengths() + '\n');
+ }
+ }
+
+ writer.close();
+ journalFileTmp.renameTo(journalFile);
+ journalWriter = new BufferedWriter(new FileWriter(journalFile, true));
+ }
+
+ private static void deleteIfExists(File file) throws IOException {
+ /*try {
+ Libcore.os.remove(file.getPath());
+ } catch (ErrnoException errnoException) {
+ if (errnoException.errno != OsConstants.ENOENT) {
+ throw errnoException.rethrowAsIOException();
+ }
+ }*/
+ if (file.exists() && !file.delete()) {
+ throw new IOException();
+ }
+ }
+
+ /**
+ * Returns a snapshot of the entry named {@code key}, or null if it doesn't
+ * exist is not currently readable. If a value is returned, it is moved to
+ * the head of the LRU queue.
+ */
+ public synchronized Snapshot get(String key) throws IOException {
+ checkNotClosed();
+ validateKey(key);
+ Entry entry = lruEntries.get(key);
+ if (entry == null) {
+ return null;
+ }
+
+ if (!entry.readable) {
+ return null;
+ }
+
+ /*
+ * Open all streams eagerly to guarantee that we see a single published
+ * snapshot. If we opened streams lazily then the streams could come
+ * from different edits.
+ */
+ InputStream[] ins = new InputStream[valueCount];
+ try {
+ for (int i = 0; i < valueCount; i++) {
+ ins[i] = new FileInputStream(entry.getCleanFile(i));
+ }
+ } catch (FileNotFoundException e) {
+ // a file must have been deleted manually!
+ return null;
+ }
+
+ redundantOpCount++;
+ journalWriter.append(READ + ' ' + key + '\n');
+ if (journalRebuildRequired()) {
+ executorService.submit(cleanupCallable);
+ }
+
+ return new Snapshot(key, entry.sequenceNumber, ins);
+ }
+
+ /**
+ * Returns an editor for the entry named {@code key}, or null if another
+ * edit is in progress.
+ */
+ public Editor edit(String key) throws IOException {
+ return edit(key, ANY_SEQUENCE_NUMBER);
+ }
+
+ private synchronized Editor edit(String key, long expectedSequenceNumber) throws IOException {
+ checkNotClosed();
+ validateKey(key);
+ Entry entry = lruEntries.get(key);
+ if (expectedSequenceNumber != ANY_SEQUENCE_NUMBER
+ && (entry == null || entry.sequenceNumber != expectedSequenceNumber)) {
+ return null; // snapshot is stale
+ }
+ if (entry == null) {
+ entry = new Entry(key);
+ lruEntries.put(key, entry);
+ } else if (entry.currentEditor != null) {
+ return null; // another edit is in progress
+ }
+
+ Editor editor = new Editor(entry);
+ entry.currentEditor = editor;
+
+ // flush the journal before creating files to prevent file leaks
+ journalWriter.write(DIRTY + ' ' + key + '\n');
+ journalWriter.flush();
+ return editor;
+ }
+
+ /**
+ * Returns the directory where this cache stores its data.
+ */
+ public File getDirectory() {
+ return directory;
+ }
+
+ /**
+ * Returns the maximum number of bytes that this cache should use to store
+ * its data.
+ */
+ public long maxSize() {
+ return maxSize;
+ }
+
+ /**
+ * Returns the number of bytes currently being used to store the values in
+ * this cache. This may be greater than the max size if a background
+ * deletion is pending.
+ */
+ public synchronized long size() {
+ return size;
+ }
+
+ private synchronized void completeEdit(Editor editor, boolean success) throws IOException {
+ Entry entry = editor.entry;
+ if (entry.currentEditor != editor) {
+ throw new IllegalStateException();
+ }
+
+ // if this edit is creating the entry for the first time, every index must have a value
+ if (success && !entry.readable) {
+ for (int i = 0; i < valueCount; i++) {
+ if (!entry.getDirtyFile(i).exists()) {
+ editor.abort();
+ throw new IllegalStateException("edit didn't create file " + i);
+ }
+ }
+ }
+
+ for (int i = 0; i < valueCount; i++) {
+ File dirty = entry.getDirtyFile(i);
+ if (success) {
+ if (dirty.exists()) {
+ File clean = entry.getCleanFile(i);
+ dirty.renameTo(clean);
+ long oldLength = entry.lengths[i];
+ long newLength = clean.length();
+ entry.lengths[i] = newLength;
+ size = size - oldLength + newLength;
+ }
+ } else {
+ deleteIfExists(dirty);
+ }
+ }
+
+ redundantOpCount++;
+ entry.currentEditor = null;
+ if (entry.readable | success) {
+ entry.readable = true;
+ journalWriter.write(CLEAN + ' ' + entry.key + entry.getLengths() + '\n');
+ if (success) {
+ entry.sequenceNumber = nextSequenceNumber++;
+ }
+ } else {
+ lruEntries.remove(entry.key);
+ journalWriter.write(REMOVE + ' ' + entry.key + '\n');
+ }
+
+ if (size > maxSize || journalRebuildRequired()) {
+ executorService.submit(cleanupCallable);
+ }
+ }
+
+ /**
+ * We only rebuild the journal when it will halve the size of the journal
+ * and eliminate at least 2000 ops.
+ */
+ private boolean journalRebuildRequired() {
+ final int REDUNDANT_OP_COMPACT_THRESHOLD = 2000;
+ return redundantOpCount >= REDUNDANT_OP_COMPACT_THRESHOLD
+ && redundantOpCount >= lruEntries.size();
+ }
+
+ /**
+ * Drops the entry for {@code key} if it exists and can be removed. Entries
+ * actively being edited cannot be removed.
+ *
+ * @return true if an entry was removed.
+ */
+ public synchronized boolean remove(String key) throws IOException {
+ checkNotClosed();
+ validateKey(key);
+ Entry entry = lruEntries.get(key);
+ if (entry == null || entry.currentEditor != null) {
+ return false;
+ }
+
+ for (int i = 0; i < valueCount; i++) {
+ File file = entry.getCleanFile(i);
+ if (!file.delete()) {
+ throw new IOException("failed to delete " + file);
+ }
+ size -= entry.lengths[i];
+ entry.lengths[i] = 0;
+ }
+
+ redundantOpCount++;
+ journalWriter.append(REMOVE + ' ' + key + '\n');
+ lruEntries.remove(key);
+
+ if (journalRebuildRequired()) {
+ executorService.submit(cleanupCallable);
+ }
+
+ return true;
+ }
+
+ /**
+ * Returns true if this cache has been closed.
+ */
+ public boolean isClosed() {
+ return journalWriter == null;
+ }
+
+ private void checkNotClosed() {
+ if (journalWriter == null) {
+ throw new IllegalStateException("cache is closed");
+ }
+ }
+
+ /**
+ * Force buffered operations to the filesystem.
+ */
+ public synchronized void flush() throws IOException {
+ checkNotClosed();
+ trimToSize();
+ journalWriter.flush();
+ }
+
+ /**
+ * Closes this cache. Stored values will remain on the filesystem.
+ */
+ public synchronized void close() throws IOException {
+ if (journalWriter == null) {
+ return; // already closed
+ }
+ for (Entry entry : new ArrayList<Entry>(lruEntries.values())) {
+ if (entry.currentEditor != null) {
+ entry.currentEditor.abort();
+ }
+ }
+ trimToSize();
+ journalWriter.close();
+ journalWriter = null;
+ }
+
+ private void trimToSize() throws IOException {
+ while (size > maxSize) {
+ Map.Entry<String, Entry> toEvict = lruEntries.entrySet().iterator().next();//lruEntries.eldest();
+ remove(toEvict.getKey());
+ }
+ }
+
+ /**
+ * Closes the cache and deletes all of its stored values. This will delete
+ * all files in the cache directory including files that weren't created by
+ * the cache.
+ */
+ public void delete() throws IOException {
+ close();
+ /*IoUtils.*/deleteContents(directory);
+ }
+
+ private void validateKey(String key) {
+ if (key.contains(" ") || key.contains("\n") || key.contains("\r")) {
+ throw new IllegalArgumentException(
+ "keys must not contain spaces or newlines: \"" + key + "\"");
+ }
+ }
+
+ private static String inputStreamToString(InputStream in) throws IOException {
+ return /*Streams.*/readFully(new InputStreamReader(in, /*Charsets.*/UTF_8));
+ }
+
+ /**
+ * A snapshot of the values for an entry.
+ */
+ public final class Snapshot implements Closeable {
+ private final String key;
+ private final long sequenceNumber;
+ private final InputStream[] ins;
+
+ private Snapshot(String key, long sequenceNumber, InputStream[] ins) {
+ this.key = key;
+ this.sequenceNumber = sequenceNumber;
+ this.ins = ins;
+ }
+
+ /**
+ * Returns an editor for this snapshot's entry, or null if either the
+ * entry has changed since this snapshot was created or if another edit
+ * is in progress.
+ */
+ public Editor edit() throws IOException {
+ return DiskLruCache.this.edit(key, sequenceNumber);
+ }
+
+ /**
+ * Returns the unbuffered stream with the value for {@code index}.
+ */
+ public InputStream getInputStream(int index) {
+ return ins[index];
+ }
+
+ /**
+ * Returns the string value for {@code index}.
+ */
+ public String getString(int index) throws IOException {
+ return inputStreamToString(getInputStream(index));
+ }
+
+ @Override public void close() {
+ for (InputStream in : ins) {
+ /*IoUtils.*/closeQuietly(in);
+ }
+ }
+ }
+
+ /**
+ * Edits the values for an entry.
+ */
+ public final class Editor {
+ private final Entry entry;
+ private boolean hasErrors;
+
+ private Editor(Entry entry) {
+ this.entry = entry;
+ }
+
+ /**
+ * Returns an unbuffered input stream to read the last committed value,
+ * or null if no value has been committed.
+ */
+ public InputStream newInputStream(int index) throws IOException {
+ synchronized (DiskLruCache.this) {
+ if (entry.currentEditor != this) {
+ throw new IllegalStateException();
+ }
+ if (!entry.readable) {
+ return null;
+ }
+ return new FileInputStream(entry.getCleanFile(index));
+ }
+ }
+
+ /**
+ * Returns the last committed value as a string, or null if no value
+ * has been committed.
+ */
+ public String getString(int index) throws IOException {
+ InputStream in = newInputStream(index);
+ return in != null ? inputStreamToString(in) : null;
+ }
+
+ /**
+ * Returns a new unbuffered output stream to write the value at
+ * {@code index}. If the underlying output stream encounters errors
+ * when writing to the filesystem, this edit will be aborted when
+ * {@link #commit} is called. The returned output stream does not throw
+ * IOExceptions.
+ */
+ public OutputStream newOutputStream(int index) throws IOException {
+ synchronized (DiskLruCache.this) {
+ if (entry.currentEditor != this) {
+ throw new IllegalStateException();
+ }
+ return new FaultHidingOutputStream(new FileOutputStream(entry.getDirtyFile(index)));
+ }
+ }
+
+ /**
+ * Sets the value at {@code index} to {@code value}.
+ */
+ public void set(int index, String value) throws IOException {
+ Writer writer = null;
+ try {
+ writer = new OutputStreamWriter(newOutputStream(index), /*Charsets.*/UTF_8);
+ writer.write(value);
+ } finally {
+ /*IoUtils.*/closeQuietly(writer);
+ }
+ }
+
+ /**
+ * Commits this edit so it is visible to readers. This releases the
+ * edit lock so another edit may be started on the same key.
+ */
+ public void commit() throws IOException {
+ if (hasErrors) {
+ completeEdit(this, false);
+ remove(entry.key); // the previous entry is stale
+ } else {
+ completeEdit(this, true);
+ }
+ }
+
+ /**
+ * Aborts this edit. This releases the edit lock so another edit may be
+ * started on the same key.
+ */
+ public void abort() throws IOException {
+ completeEdit(this, false);
+ }
+
+ private class FaultHidingOutputStream extends FilterOutputStream {
+ private FaultHidingOutputStream(OutputStream out) {
+ super(out);
+ }
+
+ @Override public void write(int oneByte) {
+ try {
+ out.write(oneByte);
+ } catch (IOException e) {
+ hasErrors = true;
+ }
+ }
+
+ @Override public void write(byte[] buffer, int offset, int length) {
+ try {
+ out.write(buffer, offset, length);
+ } catch (IOException e) {
+ hasErrors = true;
+ }
+ }
+
+ @Override public void close() {
+ try {
+ out.close();
+ } catch (IOException e) {
+ hasErrors = true;
+ }
+ }
+
+ @Override public void flush() {
+ try {
+ out.flush();
+ } catch (IOException e) {
+ hasErrors = true;
+ }
+ }
+ }
+ }
+
+ private final class Entry {
+ private final String key;
+
+ /** Lengths of this entry's files. */
+ private final long[] lengths;
+
+ /** True if this entry has ever been published */
+ private boolean readable;
+
+ /** The ongoing edit or null if this entry is not being edited. */
+ private Editor currentEditor;
+
+ /** The sequence number of the most recently committed edit to this entry. */
+ private long sequenceNumber;
+
+ private Entry(String key) {
+ this.key = key;
+ this.lengths = new long[valueCount];
+ }
+
+ public String getLengths() throws IOException {
+ StringBuilder result = new StringBuilder();
+ for (long size : lengths) {
+ result.append(' ').append(size);
+ }
+ return result.toString();
+ }
+
+ /**
+ * Set lengths using decimal numbers like "10123".
+ */
+ private void setLengths(String[] strings) throws IOException {
+ if (strings.length != valueCount) {
+ throw invalidLengths(strings);
+ }
+
+ try {
+ for (int i = 0; i < strings.length; i++) {
+ lengths[i] = Long.parseLong(strings[i]);
+ }
+ } catch (NumberFormatException e) {
+ throw invalidLengths(strings);
+ }
+ }
+
+ private IOException invalidLengths(String[] strings) throws IOException {
+ throw new IOException("unexpected journal line: " + Arrays.toString(strings));
+ }
+
+ public File getCleanFile(int i) {
+ return new File(directory, key + "." + i);
+ }
+
+ public File getDirtyFile(int i) {
+ return new File(directory, key + "." + i + ".tmp");
+ }
+ }
+}
diff --git a/src/com/koushikdutta/urlimageviewhelper/ImageArrayAdapter.java b/src/com/koushikdutta/urlimageviewhelper/ImageArrayAdapter.java
new file mode 100644
index 0000000..4fbd9a1
--- /dev/null
+++ b/src/com/koushikdutta/urlimageviewhelper/ImageArrayAdapter.java
@@ -0,0 +1,62 @@
+package com.koushikdutta.urlimageviewhelper;
+
+import android.app.Activity;
+import android.content.Context;
+import android.view.LayoutInflater;
+import android.view.View;
+import android.view.ViewGroup;
+import android.widget.ArrayAdapter;
+import android.widget.CheckedTextView;
+import android.widget.ImageView;
+
+import com.android.settings.R;
+
+/**
+ * The ImageArrayAdapter is the array adapter used for displaying an additional
+ * image to a list preference item.
+ *
+ * @author Casper Wakkers
+ */
+public class ImageArrayAdapter extends ArrayAdapter<CharSequence> {
+ private int index = 0;
+ private int[] resourceIds = null;
+
+ /**
+ * ImageArrayAdapter constructor.
+ *
+ * @param context the context.
+ * @param textViewResourceId resource id of the text view.
+ * @param objects to be displayed.
+ * @param ids resource id of the images to be displayed.
+ * @param i index of the previous selected item.
+ */
+ public ImageArrayAdapter(Context context, int textViewResourceId,
+ CharSequence[] objects, int[] ids, int i) {
+ super(context, textViewResourceId, objects);
+
+ index = i;
+ resourceIds = ids;
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ public View getView(int position, View convertView, ViewGroup parent) {
+ LayoutInflater inflater = ((Activity) getContext()).getLayoutInflater();
+ View row = inflater.inflate(R.layout.image_list_preference, parent, false);
+
+ ImageView imageView = (ImageView) row.findViewById(R.id.image);
+ imageView.setImageResource(resourceIds[position]);
+
+ // CheckedTextView checkedTextView = (CheckedTextView)row.findViewById(
+ // R.id.check);
+ //
+ // checkedTextView.setText(getItem(position));
+
+ // if (position == index) {
+ // checkedTextView.setChecked(true);
+ // }
+
+ return row;
+ }
+}
diff --git a/src/com/koushikdutta/urlimageviewhelper/ImageListPreference.java b/src/com/koushikdutta/urlimageviewhelper/ImageListPreference.java
new file mode 100644
index 0000000..d4e5afe
--- /dev/null
+++ b/src/com/koushikdutta/urlimageviewhelper/ImageListPreference.java
@@ -0,0 +1,74 @@
+package com.koushikdutta.urlimageviewhelper;
+
+import android.app.AlertDialog.Builder;
+import android.content.Context;
+import android.content.res.TypedArray;
+import android.preference.ListPreference;
+import android.util.AttributeSet;
+import android.view.View;
+import android.view.ViewGroup;
+import android.widget.ImageView;
+import android.widget.ListAdapter;
+
+import com.android.settings.R;
+
+public class ImageListPreference extends ListPreference {
+ private int[] resourceIds = null;
+
+ private int mSummaryImageResourceId;
+ /**
+ * Constructor of the ImageListPreference. Initializes the custom images.
+ *
+ * @param context application context.
+ * @param attrs custom xml attributes.
+ */
+ public ImageListPreference(Context context, AttributeSet attrs) {
+ super(context, attrs);
+
+ TypedArray typedArray = context.obtainStyledAttributes(attrs,
+ R.styleable.ImageListPreference);
+ mSummaryImageResourceId = typedArray.getResourceId(R.styleable.ImageListPreference_summaryImage, 0);
+
+ String[] imageNames = context.getResources().getStringArray(
+ typedArray.getResourceId(typedArray.getIndexCount() - 1, -1));
+
+ resourceIds = new int[imageNames.length];
+
+ for (int i = 0; i < imageNames.length; i++) {
+ String imageName = imageNames[i].substring(
+ imageNames[i].indexOf('/') + 1,
+ imageNames[i].lastIndexOf('.'));
+
+ resourceIds[i] = context.getResources().getIdentifier(imageName,
+ null, context.getPackageName());
+ }
+
+ typedArray.recycle();
+ }
+
+ @Override
+ protected View onCreateView(ViewGroup parent) {
+
+ View layout = View.inflate(getContext(), R.layout.summary_image_preference, null);
+
+ ImageView mSummaryImage = (ImageView) layout.findViewById(R.id.summary_image);
+ mSummaryImage.setImageResource(mSummaryImageResourceId);
+
+ return layout;
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ protected void onPrepareDialogBuilder(Builder builder) {
+ int index = findIndexOfValue(getSharedPreferences().getString(
+ getKey(), "1"));
+
+ ListAdapter listAdapter = new ImageArrayAdapter(getContext(),
+ R.layout.image_list_preference, getEntries(), resourceIds, index);
+
+ // Order matters.
+ builder.setAdapter(listAdapter, this);
+ super.onPrepareDialogBuilder(builder);
+ }
+}
diff --git a/src/com/koushikdutta/urlimageviewhelper/LruCache.java b/src/com/koushikdutta/urlimageviewhelper/LruCache.java
new file mode 100644
index 0000000..d5de00c
--- /dev/null
+++ b/src/com/koushikdutta/urlimageviewhelper/LruCache.java
@@ -0,0 +1,323 @@
+/*
+ * Copyright (C) 2011 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.koushikdutta.urlimageviewhelper;
+
+import java.util.LinkedHashMap;
+import java.util.Map;
+
+/**
+ * Static library version of {@link android.util.LruCache}. Used to write apps
+ * that run on API levels prior to 12. When running on API level 12 or above,
+ * this implementation is still used; it does not try to switch to the
+ * framework's implementation. See the framework SDK documentation for a class
+ * overview.
+ */
+public class LruCache<K, V> {
+ private final LinkedHashMap<K, V> map;
+
+ /** Size of this cache in units. Not necessarily the number of elements. */
+ private int size;
+ private int maxSize;
+
+ private int putCount;
+ private int createCount;
+ private int evictionCount;
+ private int hitCount;
+ private int missCount;
+
+ /**
+ * @param maxSize for caches that do not override {@link #sizeOf}, this is
+ * the maximum number of entries in the cache. For all other caches,
+ * this is the maximum sum of the sizes of the entries in this cache.
+ */
+ public LruCache(int maxSize) {
+ if (maxSize <= 0) {
+ throw new IllegalArgumentException("maxSize <= 0");
+ }
+ this.maxSize = maxSize;
+ this.map = new LinkedHashMap<K, V>(0, 0.75f, true);
+ }
+
+ /**
+ * Returns the value for {@code key} if it exists in the cache or can be
+ * created by {@code #create}. If a value was returned, it is moved to the
+ * head of the queue. This returns null if a value is not cached and cannot
+ * be created.
+ */
+ public final V get(K key) {
+ if (key == null) {
+ throw new NullPointerException("key == null");
+ }
+
+ V mapValue;
+ synchronized (this) {
+ mapValue = map.get(key);
+ if (mapValue != null) {
+ hitCount++;
+ return mapValue;
+ }
+ missCount++;
+ }
+
+ /*
+ * Attempt to create a value. This may take a long time, and the map
+ * may be different when create() returns. If a conflicting value was
+ * added to the map while create() was working, we leave that value in
+ * the map and release the created value.
+ */
+
+ V createdValue = create(key);
+ if (createdValue == null) {
+ return null;
+ }
+
+ synchronized (this) {
+ createCount++;
+ mapValue = map.put(key, createdValue);
+
+ if (mapValue != null) {
+ // There was a conflict so undo that last put
+ map.put(key, mapValue);
+ } else {
+ size += safeSizeOf(key, createdValue);
+ }
+ }
+
+ if (mapValue != null) {
+ entryRemoved(false, key, createdValue, mapValue);
+ return mapValue;
+ } else {
+ trimToSize(maxSize);
+ return createdValue;
+ }
+ }
+
+ /**
+ * Caches {@code value} for {@code key}. The value is moved to the head of
+ * the queue.
+ *
+ * @return the previous value mapped by {@code key}.
+ */
+ public final V put(K key, V value) {
+ if (key == null || value == null) {
+ throw new NullPointerException("key == null || value == null");
+ }
+
+ V previous;
+ synchronized (this) {
+ putCount++;
+ size += safeSizeOf(key, value);
+ previous = map.put(key, value);
+ if (previous != null) {
+ size -= safeSizeOf(key, previous);
+ }
+ }
+
+ if (previous != null) {
+ entryRemoved(false, key, previous, value);
+ }
+
+ trimToSize(maxSize);
+ return previous;
+ }
+
+ /**
+ * @param maxSize the maximum size of the cache before returning. May be -1
+ * to evict even 0-sized elements.
+ */
+ private void trimToSize(int maxSize) {
+ while (true) {
+ K key;
+ V value;
+ synchronized (this) {
+ if (size < 0 || (map.isEmpty() && size != 0)) {
+ throw new IllegalStateException(getClass().getName()
+ + ".sizeOf() is reporting inconsistent results!");
+ }
+
+ if (size <= maxSize || map.isEmpty()) {
+ break;
+ }
+
+ Map.Entry<K, V> toEvict = map.entrySet().iterator().next();
+ key = toEvict.getKey();
+ value = toEvict.getValue();
+ map.remove(key);
+ size -= safeSizeOf(key, value);
+ evictionCount++;
+ }
+
+ entryRemoved(true, key, value, null);
+ }
+ }
+
+ /**
+ * Removes the entry for {@code key} if it exists.
+ *
+ * @return the previous value mapped by {@code key}.
+ */
+ public final V remove(K key) {
+ if (key == null) {
+ throw new NullPointerException("key == null");
+ }
+
+ V previous;
+ synchronized (this) {
+ previous = map.remove(key);
+ if (previous != null) {
+ size -= safeSizeOf(key, previous);
+ }
+ }
+
+ if (previous != null) {
+ entryRemoved(false, key, previous, null);
+ }
+
+ return previous;
+ }
+
+ /**
+ * Called for entries that have been evicted or removed. This method is
+ * invoked when a value is evicted to make space, removed by a call to
+ * {@link #remove}, or replaced by a call to {@link #put}. The default
+ * implementation does nothing.
+ *
+ * <p>The method is called without synchronization: other threads may
+ * access the cache while this method is executing.
+ *
+ * @param evicted true if the entry is being removed to make space, false
+ * if the removal was caused by a {@link #put} or {@link #remove}.
+ * @param newValue the new value for {@code key}, if it exists. If non-null,
+ * this removal was caused by a {@link #put}. Otherwise it was caused by
+ * an eviction or a {@link #remove}.
+ */
+ protected void entryRemoved(boolean evicted, K key, V oldValue, V newValue) {}
+
+ /**
+ * Called after a cache miss to compute a value for the corresponding key.
+ * Returns the computed value or null if no value can be computed. The
+ * default implementation returns null.
+ *
+ * <p>The method is called without synchronization: other threads may
+ * access the cache while this method is executing.
+ *
+ * <p>If a value for {@code key} exists in the cache when this method
+ * returns, the created value will be released with {@link #entryRemoved}
+ * and discarded. This can occur when multiple threads request the same key
+ * at the same time (causing multiple values to be created), or when one
+ * thread calls {@link #put} while another is creating a value for the same
+ * key.
+ */
+ protected V create(K key) {
+ return null;
+ }
+
+ private int safeSizeOf(K key, V value) {
+ int result = sizeOf(key, value);
+ if (result < 0) {
+ throw new IllegalStateException("Negative size: " + key + "=" + value);
+ }
+ return result;
+ }
+
+ /**
+ * Returns the size of the entry for {@code key} and {@code value} in
+ * user-defined units. The default implementation returns 1 so that size
+ * is the number of entries and max size is the maximum number of entries.
+ *
+ * <p>An entry's size must not change while it is in the cache.
+ */
+ protected int sizeOf(K key, V value) {
+ return 1;
+ }
+
+ /**
+ * Clear the cache, calling {@link #entryRemoved} on each removed entry.
+ */
+ public final void evictAll() {
+ trimToSize(-1); // -1 will evict 0-sized elements
+ }
+
+ /**
+ * For caches that do not override {@link #sizeOf}, this returns the number
+ * of entries in the cache. For all other caches, this returns the sum of
+ * the sizes of the entries in this cache.
+ */
+ public synchronized final int size() {
+ return size;
+ }
+
+ /**
+ * For caches that do not override {@link #sizeOf}, this returns the maximum
+ * number of entries in the cache. For all other caches, this returns the
+ * maximum sum of the sizes of the entries in this cache.
+ */
+ public synchronized final int maxSize() {
+ return maxSize;
+ }
+
+ /**
+ * Returns the number of times {@link #get} returned a value.
+ */
+ public synchronized final int hitCount() {
+ return hitCount;
+ }
+
+ /**
+ * Returns the number of times {@link #get} returned null or required a new
+ * value to be created.
+ */
+ public synchronized final int missCount() {
+ return missCount;
+ }
+
+ /**
+ * Returns the number of times {@link #create(Object)} returned a value.
+ */
+ public synchronized final int createCount() {
+ return createCount;
+ }
+
+ /**
+ * Returns the number of times {@link #put} was called.
+ */
+ public synchronized final int putCount() {
+ return putCount;
+ }
+
+ /**
+ * Returns the number of values that have been evicted.
+ */
+ public synchronized final int evictionCount() {
+ return evictionCount;
+ }
+
+ /**
+ * Returns a copy of the current contents of the cache, ordered from least
+ * recently accessed to most recently accessed.
+ */
+ public synchronized final Map<K, V> snapshot() {
+ return new LinkedHashMap<K, V>(map);
+ }
+
+ @Override public synchronized final String toString() {
+ int accesses = hitCount + missCount;
+ int hitPercent = accesses != 0 ? (100 * hitCount / accesses) : 0;
+ return String.format("LruCache[maxSize=%d,hits=%d,misses=%d,hitRate=%d%%]",
+ maxSize, hitCount, missCount, hitPercent);
+ }
+}
diff --git a/src/com/koushikdutta/urlimageviewhelper/SoftReferenceHashTable.java b/src/com/koushikdutta/urlimageviewhelper/SoftReferenceHashTable.java
new file mode 100644
index 0000000..e376061
--- /dev/null
+++ b/src/com/koushikdutta/urlimageviewhelper/SoftReferenceHashTable.java
@@ -0,0 +1,33 @@
+package com.koushikdutta.urlimageviewhelper;
+
+import java.lang.ref.SoftReference;
+import java.util.Hashtable;
+
+public class SoftReferenceHashTable<K,V> {
+ Hashtable<K, SoftReference<V>> mTable = new Hashtable<K, SoftReference<V>>();
+
+ public V put(K key, V value) {
+ SoftReference<V> old = mTable.put(key, new SoftReference<V>(value));
+ if (old == null)
+ return null;
+ return old.get();
+ }
+
+ public V get(K key) {
+ SoftReference<V> val = mTable.get(key);
+ if (val == null)
+ return null;
+ V ret = val.get();
+ if (ret == null)
+ mTable.remove(key);
+ return ret;
+ }
+
+ public V remove(K k) {
+ SoftReference<V> v = mTable.remove(k);
+ if (v == null)
+ return null;
+ return v.get();
+ }
+}
+
diff --git a/src/com/koushikdutta/urlimageviewhelper/UrlImageCache.java b/src/com/koushikdutta/urlimageviewhelper/UrlImageCache.java
new file mode 100644
index 0000000..8b7ac29
--- /dev/null
+++ b/src/com/koushikdutta/urlimageviewhelper/UrlImageCache.java
@@ -0,0 +1,14 @@
+package com.koushikdutta.urlimageviewhelper;
+
+import android.graphics.drawable.Drawable;
+
+public final class UrlImageCache extends SoftReferenceHashTable<String, Drawable> {
+ private static UrlImageCache mInstance = new UrlImageCache();
+
+ public static UrlImageCache getInstance() {
+ return mInstance;
+ }
+
+ private UrlImageCache() {
+ }
+}
diff --git a/src/com/koushikdutta/urlimageviewhelper/UrlImageViewCallback.java b/src/com/koushikdutta/urlimageviewhelper/UrlImageViewCallback.java
new file mode 100644
index 0000000..37c8e98
--- /dev/null
+++ b/src/com/koushikdutta/urlimageviewhelper/UrlImageViewCallback.java
@@ -0,0 +1,8 @@
+package com.koushikdutta.urlimageviewhelper;
+
+import android.graphics.drawable.Drawable;
+import android.widget.ImageView;
+
+public interface UrlImageViewCallback {
+ void onLoaded(ImageView imageView, Drawable loadedDrawable, String url, boolean loadedFromCache);
+}
diff --git a/src/com/koushikdutta/urlimageviewhelper/UrlImageViewHelper.java b/src/com/koushikdutta/urlimageviewhelper/UrlImageViewHelper.java
new file mode 100644
index 0000000..c5c7849
--- /dev/null
+++ b/src/com/koushikdutta/urlimageviewhelper/UrlImageViewHelper.java
@@ -0,0 +1,513 @@
+package com.koushikdutta.urlimageviewhelper;
+
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.FileOutputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStream;
+import java.net.HttpURLConnection;
+import java.util.ArrayList;
+import java.util.HashSet;
+import java.util.Hashtable;
+
+import junit.framework.Assert;
+
+import org.apache.http.HttpEntity;
+import org.apache.http.HttpResponse;
+import org.apache.http.NameValuePair;
+import org.apache.http.client.methods.HttpGet;
+import org.apache.http.client.params.HttpClientParams;
+import org.apache.http.params.BasicHttpParams;
+import org.apache.http.params.HttpParams;
+import java.io.IOException;
+import java.net.InetAddress;
+import java.net.Socket;
+import java.net.UnknownHostException;
+import android.annotation.TargetApi;
+import android.app.Activity;
+import android.app.ActivityManager;
+import android.content.ContentResolver;
+import android.content.Context;
+import android.content.res.AssetManager;
+import android.content.res.Resources;
+import android.graphics.Bitmap;
+import android.graphics.BitmapFactory;
+import android.graphics.BitmapFactory.Options;
+import android.graphics.drawable.BitmapDrawable;
+import android.graphics.drawable.Drawable;
+import android.net.Uri;
+import android.net.http.AndroidHttpClient;
+import android.os.AsyncTask;
+import android.os.Build;
+import android.os.Looper;
+import android.provider.ContactsContract;
+import android.util.DisplayMetrics;
+import android.util.Log;
+import android.view.Display;
+import android.view.WindowManager;
+import android.widget.ImageView;
+
+public final class UrlImageViewHelper {
+
+ public static int copyStream(InputStream input, OutputStream output) throws IOException
+ {
+ byte[] stuff = new byte[1024];
+ int read = 0;
+ int total = 0;
+ while ((read = input.read(stuff)) != -1)
+ {
+ output.write(stuff, 0, read);
+ total += read;
+ }
+ return total;
+ }
+
+ static Resources mResources;
+ static DisplayMetrics mMetrics;
+ private static void prepareResources(Context context) {
+ if (mMetrics != null)
+ return;
+ mMetrics = new DisplayMetrics();
+ Activity act = (Activity)context;
+ act.getWindowManager().getDefaultDisplay().getMetrics(mMetrics);
+ AssetManager mgr = context.getAssets();
+ mResources = new Resources(mgr, mMetrics, context.getResources().getConfiguration());
+ }
+
+ private static Drawable loadDrawableFromStream(Context context, String url, String filename, int targetWidth, int targetHeight) {
+ prepareResources(context);
+
+// Log.v(Constants.LOGTAG,targetWidth);
+// Log.v(Constants.LOGTAG,targetHeight);
+ try {
+ BitmapFactory.Options o = new BitmapFactory.Options();
+ o.inJustDecodeBounds = true;
+ FileInputStream stream = new FileInputStream(filename);
+ BitmapFactory.decodeStream(stream, null, o);
+ stream.close();
+ stream = new FileInputStream(filename);
+ int scale = 0;
+ while ((o.outWidth >> scale) > targetWidth || (o.outHeight >> scale) > targetHeight) {
+ Log.v(Constants.LOGTAG,"downsampling");
+ scale++;
+ }
+ o = new Options();
+ o.inSampleSize = 1 << scale;
+ final Bitmap bitmap = BitmapFactory.decodeStream(stream, null, o);
+ if (Constants.LOG_ENABLED)
+ Log.i(Constants.LOGTAG, String.format("Loaded bitmap (%dx%d).", bitmap.getWidth(), bitmap.getHeight()));
+ BitmapDrawable bd = new BitmapDrawable(mResources, bitmap);
+ return new ZombieDrawable(url, bd);
+ }
+ catch (IOException e) {
+ return null;
+ }
+ }
+
+ public static final int CACHE_DURATION_INFINITE = Integer.MAX_VALUE;
+ public static final int CACHE_DURATION_ONE_DAY = 1000 * 60 * 60 * 24;
+ public static final int CACHE_DURATION_TWO_DAYS = CACHE_DURATION_ONE_DAY * 2;
+ public static final int CACHE_DURATION_THREE_DAYS = CACHE_DURATION_ONE_DAY * 3;
+ public static final int CACHE_DURATION_FOUR_DAYS = CACHE_DURATION_ONE_DAY * 4;
+ public static final int CACHE_DURATION_FIVE_DAYS = CACHE_DURATION_ONE_DAY * 5;
+ public static final int CACHE_DURATION_SIX_DAYS = CACHE_DURATION_ONE_DAY * 6;
+ public static final int CACHE_DURATION_ONE_WEEK = CACHE_DURATION_ONE_DAY * 7;
+
+ public static void setUrlDrawable(final ImageView imageView, final String url, int defaultResource) {
+ setUrlDrawable(imageView.getContext(), imageView, url, defaultResource, CACHE_DURATION_THREE_DAYS);
+ }
+
+ public static void setUrlDrawable(final ImageView imageView, final String url) {
+ setUrlDrawable(imageView.getContext(), imageView, url, null, CACHE_DURATION_THREE_DAYS, null);
+ }
+
+ public static void loadUrlDrawable(final Context context, final String url) {
+ setUrlDrawable(context, null, url, null, CACHE_DURATION_THREE_DAYS, null);
+ }
+
+ public static void setUrlDrawable(final ImageView imageView, final String url, Drawable defaultDrawable) {
+ setUrlDrawable(imageView.getContext(), imageView, url, defaultDrawable, CACHE_DURATION_THREE_DAYS, null);
+ }
+
+ public static void setUrlDrawable(final ImageView imageView, final String url, int defaultResource, long cacheDurationMs) {
+ setUrlDrawable(imageView.getContext(), imageView, url, defaultResource, cacheDurationMs);
+ }
+
+ public static void loadUrlDrawable(final Context context, final String url, long cacheDurationMs) {
+ setUrlDrawable(context, null, url, null, cacheDurationMs, null);
+ }
+
+ public static void setUrlDrawable(final ImageView imageView, final String url, Drawable defaultDrawable, long cacheDurationMs) {
+ setUrlDrawable(imageView.getContext(), imageView, url, defaultDrawable, cacheDurationMs, null);
+ }
+
+ private static void setUrlDrawable(final Context context, final ImageView imageView, final String url, int defaultResource, long cacheDurationMs) {
+ Drawable d = null;
+ if (defaultResource != 0)
+ d = imageView.getResources().getDrawable(defaultResource);
+ setUrlDrawable(context, imageView, url, d, cacheDurationMs, null);
+ }
+
+ public static void setUrlDrawable(final ImageView imageView, final String url, int defaultResource, UrlImageViewCallback callback) {
+ setUrlDrawable(imageView.getContext(), imageView, url, defaultResource, CACHE_DURATION_THREE_DAYS, callback);
+ }
+
+ public static void setUrlDrawable(final ImageView imageView, final String url, UrlImageViewCallback callback) {
+ setUrlDrawable(imageView.getContext(), imageView, url, null, CACHE_DURATION_THREE_DAYS, callback);
+ }
+
+ public static void loadUrlDrawable(final Context context, final String url, UrlImageViewCallback callback) {
+ setUrlDrawable(context, null, url, null, CACHE_DURATION_THREE_DAYS, callback);
+ }
+
+ public static void setUrlDrawable(final ImageView imageView, final String url, Drawable defaultDrawable, UrlImageViewCallback callback) {
+ setUrlDrawable(imageView.getContext(), imageView, url, defaultDrawable, CACHE_DURATION_THREE_DAYS, callback);
+ }
+
+ public static void setUrlDrawable(final ImageView imageView, final String url, int defaultResource, long cacheDurationMs, UrlImageViewCallback callback) {
+ setUrlDrawable(imageView.getContext(), imageView, url, defaultResource, cacheDurationMs, callback);
+ }
+
+ public static void loadUrlDrawable(final Context context, final String url, long cacheDurationMs, UrlImageViewCallback callback) {
+ setUrlDrawable(context, null, url, null, cacheDurationMs, callback);
+ }
+
+ public static void setUrlDrawable(final ImageView imageView, final String url, Drawable defaultDrawable, long cacheDurationMs, UrlImageViewCallback callback) {
+ setUrlDrawable(imageView.getContext(), imageView, url, defaultDrawable, cacheDurationMs, callback);
+ }
+
+ private static void setUrlDrawable(final Context context, final ImageView imageView, final String url, int defaultResource, long cacheDurationMs, UrlImageViewCallback callback) {
+ Drawable d = null;
+ if (defaultResource != 0)
+ d = imageView.getResources().getDrawable(defaultResource);
+ setUrlDrawable(context, imageView, url, d, cacheDurationMs, callback);
+ }
+
+ private static boolean isNullOrEmpty(CharSequence s) {
+ return (s == null || s.equals("") || s.equals("null") || s.equals("NULL"));
+ }
+
+ private static boolean mHasCleaned = false;
+
+ public static String getFilenameForUrl(String url) {
+ return "" + url.hashCode() + ".urlimage";
+ }
+
+ private static void cleanup(Context context) {
+ if (mHasCleaned)
+ return;
+ mHasCleaned = true;
+ try {
+ // purge any *.urlimage files over a week old
+ String[] files = context.getFilesDir().list();
+ if (files == null)
+ return;
+ for (String file : files) {
+ if (!file.endsWith(".urlimage"))
+ continue;
+
+ File f = new File(context.getFilesDir().getAbsolutePath() + '/' + file);
+ if (System.currentTimeMillis() > f.lastModified() + CACHE_DURATION_ONE_WEEK)
+ f.delete();
+ }
+ }
+ catch (Exception e) {
+ e.printStackTrace();
+ }
+ }
+
+ private static void setUrlDrawable(final Context context, final ImageView imageView, final String url, final Drawable defaultDrawable, long cacheDurationMs, final UrlImageViewCallback callback) {
+ cleanup(context);
+ // disassociate this ImageView from any pending downloads
+ if (isNullOrEmpty(url)) {
+ if (imageView != null)
+ imageView.setImageDrawable(defaultDrawable);
+ return;
+ }
+
+ WindowManager wm = (WindowManager)context.getSystemService(Context.WINDOW_SERVICE);
+ Display display = wm.getDefaultDisplay();
+ final int tw = display.getWidth();
+ final int th = display.getHeight();
+
+ if (mDeadCache == null)
+ mDeadCache = new UrlLruCache(getHeapSize(context) / 8);
+ Drawable drawable;
+ BitmapDrawable zd = mDeadCache.remove(url);
+ if (zd != null) {
+ // this drawable was resurrected, it should not be in the live cache
+ if (Constants.LOG_ENABLED)
+ Log.i(Constants.LOGTAG, "zombie load");
+ Assert.assertTrue(!mAllCache.contains(zd));
+ drawable = new ZombieDrawable(url, zd);
+ }
+ else {
+ drawable = mLiveCache.get(url);
+ }
+
+ if (drawable != null) {
+ if (Constants.LOG_ENABLED)
+ Log.i(Constants.LOGTAG, "Cache hit on: " + url);
+ if (imageView != null)
+ imageView.setImageDrawable(drawable);
+ if (callback != null)
+ callback.onLoaded(imageView, drawable, url, true);
+ return;
+ }
+
+ // oh noes, at this point we definitely do not have the file available in memory
+ // let's prepare for an asynchronous load of the image.
+
+ final String filename = context.getFileStreamPath(getFilenameForUrl(url)).getAbsolutePath();
+
+ // null it while it is downloading
+ if (imageView != null)
+ imageView.setImageDrawable(defaultDrawable);
+
+ // since listviews reuse their views, we need to
+ // take note of which url this view is waiting for.
+ // This may change rapidly as the list scrolls or is filtered, etc.
+ if (Constants.LOG_ENABLED)
+ Log.i(Constants.LOGTAG, "Waiting for " + url);
+ if (imageView != null)
+ mPendingViews.put(imageView, url);
+
+ ArrayList<ImageView> currentDownload = mPendingDownloads.get(url);
+ if (currentDownload != null) {
+ // Also, multiple vies may be waiting for this url.
+ // So, let's maintain a list of these views.
+ // When the url is downloaded, it sets the imagedrawable for
+ // every view in the list. It needs to also validate that
+ // the imageview is still waiting for this url.
+ if (imageView != null)
+ currentDownload.add(imageView);
+ return;
+ }
+
+ final ArrayList<ImageView> downloads = new ArrayList<ImageView>();
+ if (imageView != null)
+ downloads.add(imageView);
+ mPendingDownloads.put(url, downloads);
+
+ final int targetWidth = tw <= 0 ? Integer.MAX_VALUE : tw;
+ final int targetHeight = th <= 0 ? Integer.MAX_VALUE : th;
+ final Loader loader = new Loader() {
+ @Override
+ public void run() {
+ try {
+ result = loadDrawableFromStream(context, url, filename, targetWidth, targetHeight);
+ }
+ catch (Exception ex) {
+ }
+ }
+ };
+
+ final Runnable completion = new Runnable() {
+ @Override
+ public void run() {
+ Assert.assertEquals(Looper.myLooper(), Looper.getMainLooper());
+ Drawable usableResult = loader.result;
+ if (usableResult == null)
+ usableResult = defaultDrawable;
+ mPendingDownloads.remove(url);
+ mLiveCache.put(url, usableResult);
+ for (ImageView iv: downloads) {
+ // validate the url it is waiting for
+ String pendingUrl = mPendingViews.get(iv);
+ if (!url.equals(pendingUrl)) {
+ if (Constants.LOG_ENABLED)
+ Log.i(Constants.LOGTAG, "Ignoring out of date request to update view for " + url);
+ continue;
+ }
+ mPendingViews.remove(iv);
+ if (usableResult != null) {
+ // System.out.println(String.format("imageView: %dx%d, %dx%d", imageView.getMeasuredWidth(), imageView.getMeasuredHeight(), imageView.getWidth(), imageView.getHeight()));
+ iv.setImageDrawable(usableResult);
+// System.out.println(String.format("imageView: %dx%d, %dx%d", imageView.getMeasuredWidth(), imageView.getMeasuredHeight(), imageView.getWidth(), imageView.getHeight()));
+ if (callback != null)
+ callback.onLoaded(iv, loader.result, url, false);
+ }
+ }
+ }
+ };
+
+
+ File file = new File(filename);
+ if (file.exists()) {
+ try {
+ if (cacheDurationMs == CACHE_DURATION_INFINITE || System.currentTimeMillis() < file.lastModified() + cacheDurationMs) {
+ if (Constants.LOG_ENABLED)
+ Log.i(Constants.LOGTAG, "File Cache hit on: " + url + ". " + (System.currentTimeMillis() - file.lastModified()) + "ms old.");
+
+ AsyncTask<Void, Void, Void> fileloader = new AsyncTask<Void, Void, Void>() {
+ protected Void doInBackground(Void[] params) {
+ loader.run();
+ return null;
+ }
+ protected void onPostExecute(Void result) {
+ completion.run();
+ }
+ };
+ executeTask(fileloader);
+ return;
+ }
+ else {
+ if (Constants.LOG_ENABLED)
+ Log.i(Constants.LOGTAG, "File cache has expired. Refreshing.");
+ }
+ }
+ catch (Exception ex) {
+ }
+ }
+
+ mDownloader.download(context, url, filename, loader, completion);
+ }
+
+ private static abstract class Loader implements Runnable {
+ public Drawable result;
+ }
+
+ public static interface UrlDownloader {
+ public void download(Context context, String url, String filename, Runnable loader, Runnable completion);
+ }
+
+ private static UrlDownloader mDefaultDownloader = new UrlDownloader() {
+ @Override
+ public void download(final Context context, final String url, final String filename, final Runnable loader, final Runnable completion) {
+ AsyncTask<Void, Void, Void> downloader = new AsyncTask<Void, Void, Void>() {
+ @Override
+ protected Void doInBackground(Void... params) {
+ try {
+ InputStream is = null;
+ if (url.startsWith(ContactsContract.Contacts.CONTENT_URI.toString())) {
+ ContentResolver cr = context.getContentResolver();
+ is = ContactsContract.Contacts.openContactPhotoInputStream(cr, Uri.parse(url));
+ }
+ else {
+ final AndroidHttpClient client = AndroidHttpClient.newInstance(context.getPackageName());
+ HttpGet get = new HttpGet(url);
+ final HttpParams httpParams = new BasicHttpParams();
+ HttpClientParams.setRedirecting(httpParams, true);
+
+ if (mRequestPropertiesCallback != null) {
+ ArrayList<NameValuePair> props = mRequestPropertiesCallback.getHeadersForRequest(context, url);
+ if (props != null) {
+ for (NameValuePair pair: props) {
+ httpParams.setParameter(pair.getName(), pair.getValue());
+ }
+ }
+ }
+
+ get.setParams(httpParams);
+ HttpResponse resp = client.execute(get);
+ int status = resp.getStatusLine().getStatusCode();
+
+ if (status != HttpURLConnection.HTTP_OK) {
+ return null;
+ }
+ HttpEntity entity = resp.getEntity();
+ is = entity.getContent();
+ }
+
+ if (is != null) {
+ FileOutputStream fos = new FileOutputStream(filename);
+ copyStream(is, fos);
+ fos.close();
+ is.close();
+ }
+ loader.run();
+ return null;
+ }
+ catch (Throwable e) {
+ e.printStackTrace();
+ return null;
+ }
+ }
+
+ protected void onPostExecute(Void result) {
+ completion.run();
+ }
+ };
+
+ executeTask(downloader);
+ }
+ };
+
+ static public interface RequestPropertiesCallback {
+ public ArrayList<NameValuePair> getHeadersForRequest(Context context, String url);
+ }
+
+ static private RequestPropertiesCallback mRequestPropertiesCallback;
+ static public RequestPropertiesCallback getRequestPropertiesCallback() {
+ return mRequestPropertiesCallback;
+ }
+
+ static public void setRequestPropertiesCallback(RequestPropertiesCallback callback) {
+ mRequestPropertiesCallback = callback;
+ }
+
+
+ public static void useDownloader(UrlDownloader downloader) {
+ mDownloader = downloader;
+ }
+
+ public static void useDefaultDownloader() {
+ mDownloader = mDefaultDownloader;
+ }
+
+ public static UrlDownloader getDefaultDownloader() {
+ return mDownloader;
+ }
+
+ private static UrlImageCache mLiveCache = UrlImageCache.getInstance();
+
+ private static UrlLruCache mDeadCache;
+ private static HashSet<BitmapDrawable> mAllCache = new HashSet<BitmapDrawable>();
+ private static int getHeapSize(Context context) {
+ return ((ActivityManager)context.getSystemService(Context.ACTIVITY_SERVICE)).getMemoryClass() * 1024 * 1024;
+ }
+
+ private static class ZombieDrawable extends WrapperDrawable {
+ public ZombieDrawable(String url, BitmapDrawable drawable) {
+ super(drawable);
+ mUrl = url;
+
+ mAllCache.add(drawable);
+ mDeadCache.remove(url);
+ mLiveCache.put(url, this);
+ }
+
+ String mUrl;
+
+ @Override
+ protected void finalize() throws Throwable {
+ super.finalize();
+
+ mDeadCache.put(mUrl, mDrawable);
+ mAllCache.remove(mDrawable);
+ mLiveCache.remove(mUrl);
+ if (Constants.LOG_ENABLED)
+ Log.i(Constants.LOGTAG, "Zombie GC event");
+ System.gc();
+ }
+ }
+
+
+ private static UrlDownloader mDownloader = mDefaultDownloader;
+
+ private static void executeTask(AsyncTask<Void, Void, Void> task) {
+ if (Build.VERSION.SDK_INT < Constants.HONEYCOMB)
+ task.execute();
+ else
+ executeTaskHoneycomb(task);
+ }
+
+ @TargetApi(Constants.HONEYCOMB)
+ private static void executeTaskHoneycomb(AsyncTask<Void, Void, Void> task) {
+ task.executeOnExecutor(AsyncTask.THREAD_POOL_EXECUTOR);
+ }
+
+ private static Hashtable<ImageView, String> mPendingViews = new Hashtable<ImageView, String>();
+ private static Hashtable<String, ArrayList<ImageView>> mPendingDownloads = new Hashtable<String, ArrayList<ImageView>>();
+}
diff --git a/src/com/koushikdutta/urlimageviewhelper/UrlLruCache.java b/src/com/koushikdutta/urlimageviewhelper/UrlLruCache.java
new file mode 100644
index 0000000..5529739
--- /dev/null
+++ b/src/com/koushikdutta/urlimageviewhelper/UrlLruCache.java
@@ -0,0 +1,20 @@
+package com.koushikdutta.urlimageviewhelper;
+
+import android.graphics.Bitmap;
+import android.graphics.drawable.BitmapDrawable;
+
+public class UrlLruCache extends LruCache<String, BitmapDrawable> {
+ public UrlLruCache(int maxSize) {
+ super(maxSize);
+ }
+
+ @Override
+ protected int sizeOf(String key, BitmapDrawable value) {
+ if (value != null) {
+ Bitmap b = value.getBitmap();
+ if (b != null)
+ return b.getRowBytes() * b.getHeight();
+ }
+ return 0;
+ }
+}
diff --git a/src/com/koushikdutta/urlimageviewhelper/WrapperDrawable.java b/src/com/koushikdutta/urlimageviewhelper/WrapperDrawable.java
new file mode 100644
index 0000000..970b02c
--- /dev/null
+++ b/src/com/koushikdutta/urlimageviewhelper/WrapperDrawable.java
@@ -0,0 +1,54 @@
+package com.koushikdutta.urlimageviewhelper;
+
+import android.graphics.Canvas;
+import android.graphics.ColorFilter;
+import android.graphics.drawable.BitmapDrawable;
+import android.graphics.drawable.Drawable;
+
+class WrapperDrawable extends Drawable {
+ public WrapperDrawable(BitmapDrawable drawable) {
+ mDrawable = drawable;
+ }
+
+ BitmapDrawable mDrawable;
+
+ public WrapperDrawable(WrapperDrawable drawable) {
+ this(drawable.mDrawable);
+ }
+
+ @Override
+ public void draw(Canvas canvas) {
+ mDrawable.draw(canvas);
+ }
+
+ @Override
+ public int getOpacity() {
+ return mDrawable.getOpacity();
+ }
+
+ @Override
+ public void setAlpha(int alpha) {
+ mDrawable.setAlpha(alpha);
+ }
+
+ @Override
+ public void setColorFilter(ColorFilter cf) {
+ mDrawable.setColorFilter(cf);
+ }
+
+ @Override
+ public void setBounds(int left, int top, int right, int bottom) {
+ mDrawable.setBounds(left, top, right, bottom);
+ }
+
+ @Override
+ public int getIntrinsicHeight() {
+ return mDrawable.getIntrinsicHeight();
+ }
+
+ @Override
+ public int getIntrinsicWidth() {
+ // TODO Auto-generated method stub
+ return mDrawable.getIntrinsicWidth();
+ }
+}
