Switch from HtmlSpanner to HtmlTextView

libraries/HtmlTextView/src/org/sufficientlysecure/htmltextview/UrlImageGetter.java

@@ -0,0 +1,128 @@
+/*
+ * Copyright (C) 2013 Antarix Tandon
+ *
+ * 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 org.sufficientlysecure.htmltextview;
+
+import android.content.Context;
+import android.graphics.Canvas;
+import android.graphics.drawable.BitmapDrawable;
+import android.graphics.drawable.Drawable;
+import android.os.AsyncTask;
+import android.text.Html.ImageGetter;
+import android.view.View;
+
+import org.apache.http.HttpResponse;
+import org.apache.http.client.methods.HttpGet;
+import org.apache.http.impl.client.DefaultHttpClient;
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.net.MalformedURLException;
+
+public class UrlImageGetter implements ImageGetter {
+    Context c;
+    View container;
+
+    /**
+     * Construct the URLImageParser which will execute AsyncTask and refresh the container
+     *
+     * @param t
+     * @param c
+     */
+    public UrlImageGetter(View t, Context c) {
+        this.c = c;
+        this.container = t;
+    }
+
+    public Drawable getDrawable(String source) {
+        UrlDrawable urlDrawable = new UrlDrawable();
+
+        // get the actual source
+        ImageGetterAsyncTask asyncTask = new ImageGetterAsyncTask(urlDrawable);
+
+        asyncTask.execute(source);
+
+        // return reference to URLDrawable where I will change with actual image from
+        // the src tag
+        return urlDrawable;
+    }
+
+    public class ImageGetterAsyncTask extends AsyncTask<String, Void, Drawable> {
+        UrlDrawable urlDrawable;
+
+        public ImageGetterAsyncTask(UrlDrawable d) {
+            this.urlDrawable = d;
+        }
+
+        @Override
+        protected Drawable doInBackground(String... params) {
+            String source = params[0];
+            return fetchDrawable(source);
+        }
+
+        @Override
+        protected void onPostExecute(Drawable result) {
+            // set the correct bound according to the result from HTTP call
+            urlDrawable.setBounds(0, 0, 0 + result.getIntrinsicWidth(), 0 + result.getIntrinsicHeight());
+
+            // change the reference of the current drawable to the result
+            // from the HTTP call
+            urlDrawable.drawable = result;
+
+            // redraw the image by invalidating the container
+            UrlImageGetter.this.container.invalidate();
+        }
+
+        /**
+         * Get the Drawable from URL
+         *
+         * @param urlString
+         * @return
+         */
+        public Drawable fetchDrawable(String urlString) {
+            try {
+                InputStream is = fetch(urlString);
+                Drawable drawable = Drawable.createFromStream(is, "src");
+                drawable.setBounds(0, 0, 0 + drawable.getIntrinsicWidth(), 0 + drawable.getIntrinsicHeight());
+                return drawable;
+            } catch (Exception e) {
+                return null;
+            }
+        }
+
+        private InputStream fetch(String urlString) throws MalformedURLException, IOException {
+            DefaultHttpClient httpClient = new DefaultHttpClient();
+            HttpGet request = new HttpGet(urlString);
+            HttpResponse response = httpClient.execute(request);
+            return response.getEntity().getContent();
+        }
+    }
+
+    @SuppressWarnings("deprecation")
+    public class UrlDrawable extends BitmapDrawable {
+        // the drawable that you need to set, you could set the initial drawing
+        // with the loading image if you need to
+        protected Drawable drawable;
+
+        @Override
+        public void draw(Canvas canvas) {
+            // override the draw to facilitate refresh function later
+            if (drawable != null) {
+                drawable.draw(canvas);
+            }
+        }
+    }
+}