Android webview PageFinished reload

  mWebView=(WebView) findViewById(R.id.webView1);

   
         //  web.loadUrl(url.getimageurl());

      mWebView.setBackgroundColor(0x00000000);
      mWebView.getSettings().setLayoutAlgorithm(LayoutAlgorithm.SINGLE_COLUMN);
      mWebView.loadUrl(path);
     
      mWebView.setWebViewClient(new WebViewClient() {

             public void onPageFinished(WebView mWebView, String path) {
                  // do your stuff here
                 mWebView.getSettings().setRenderPriority(RenderPriority.HIGH);
                 mWebView.getSettings().setCacheMode(WebSettings.LOAD_NO_CACHE);
                 mWebView.loadUrl(path);
    
              }
          });

access soap service android

import org.ksoap2.SoapEnvelope;

import org.ksoap2.serialization.PropertyInfo;

import org.ksoap2.serialization.SoapObject;

import org.ksoap2.serialization.SoapPrimitive;

import org.ksoap2.serialization.SoapSerializationEnvelope;

import org.ksoap2.transport.HttpTransportSE;

  

import android.app.Activity;

import android.os.Bundle;

import android.util.Log;

import android.widget.TextView;

  

public class AndroidWebService extends Activity {

   

    private final String NAMESPACE = "http://www.webserviceX.NET/";

    private final String URL = "http://www.webservicex.net/ConvertWeight.asmx";

    private final String SOAP_ACTION = "http://www.webserviceX.NET/ConvertWeight";

    private final String METHOD_NAME = "ConvertWeight";

  

    /** Called when the activity is first created. */

    @Override

    public void onCreate(Bundle savedInstanceState) {

        super.onCreate(savedInstanceState);

        setContentView(R.layout.main);

  

        SoapObject request = new SoapObject(NAMESPACE, METHOD_NAME);

       

        String weight = "3700";

        String fromUnit = "Grams";

        String toUnit = "Kilograms";

       

        PropertyInfo weightProp =new PropertyInfo();

        weightProp.setName("Weight");

        weightProp.setValue(weight);

        weightProp.setType(double.class);

        request.addProperty(weightProp);

          

        PropertyInfo fromProp =new PropertyInfo();

        fromProp.setName("FromUnit");

        fromProp.setValue(fromUnit);

        fromProp.setType(String.class);

        request.addProperty(fromProp);

          

        PropertyInfo toProp =new PropertyInfo();

        toProp.setName("ToUnit");

        toProp.setValue(toUnit);

        toProp.setType(String.class);

        request.addProperty(toProp);

         

        SoapSerializationEnvelope envelope = new SoapSerializationEnvelope(SoapEnvelope.VER11);

        envelope.dotNet = true;

        envelope.setOutputSoapObject(request);

        HttpTransportSE androidHttpTransport = new HttpTransportSE(URL);

  

        try {

            androidHttpTransport.call(SOAP_ACTION, envelope);

            SoapPrimitive response = (SoapPrimitive)envelope.getResponse();

            Log.i("myApp", response.toString());

     

            TextView tv = new TextView(this);

            tv.setText(weight+" "+fromUnit+" equal "+response.toString()+ " "+toUnit);

            setContentView(tv);

  

        } catch (Exception e) {

            e.printStackTrace();

        }

    }

}

image download in android

import java.io.IOException;


import java.io.InputStream;
import java.lang.ref.SoftReference;
import java.net.MalformedURLException;
import java.net.URL;
import java.util.Collections;
import java.util.HashMap;
import java.util.Map;
import java.util.WeakHashMap;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

import android.graphics.Bitmap;
import android.graphics.BitmapFactory;
import android.os.Handler;
import android.os.Message;
import android.util.Log;
import android.widget.ImageView;

public enum BitmapManager {
   
     INSTANCE; 
      
         private final Map<String, SoftReference<Bitmap>> cache; 
         private final ExecutorService pool; 
         private Map<ImageView, String> imageViews = Collections 
                 .synchronizedMap(new WeakHashMap<ImageView, String>()); 
         private Bitmap placeholder; 
      
         BitmapManager() { 
             cache = new HashMap<String, SoftReference<Bitmap>>(); 
             pool = Executors.newFixedThreadPool(5); 
         } 
      
         public void setPlaceholder(Bitmap bmp) { 
             placeholder = bmp; 
         } 
      
         public Bitmap getBitmapFromCache(String url) { 
             if (cache.containsKey(url)) { 
                 return cache.get(url).get(); 
             } 
      
             return null; 
         } 
      
         public void queueJob(final String url, final ImageView imageView, 
                 final int width, final int height) { 
             /* Create handler in UI thread. */ 
             final Handler handler = new Handler() { 
                 @Override 
                 public void handleMessage(Message msg) { 
                     String tag = imageViews.get(imageView); 
                     if (tag != null && tag.equals(url)) { 
                         if (msg.obj != null) { 
                             imageView.setImageBitmap((Bitmap) msg.obj); 
                         } else { 
                             imageView.setImageBitmap(placeholder); 
                             Log.d(null, "fail " + url); 
                         } 
                     } 
                 } 
             }; 
      
             pool.submit(new Runnable() { 
                 @Override 
                 public void run() { 
                     final Bitmap bmp = downloadBitmap(url, width, height); 
                     Message message = Message.obtain(); 
                     message.obj = bmp; 
                     Log.d(null, "Item downloaded: " + url); 
      
                     handler.sendMessage(message); 
                 } 
             }); 
         } 
      
         public void loadBitmap(final String url, final ImageView imageView, 
                 final int width, final int height) { 
             imageViews.put(imageView, url); 
             Bitmap bitmap = getBitmapFromCache(url); 
      
             // check in UI thread, so no concurrency issues 
             if (bitmap != null) { 
                 Log.d(null, "Item loaded from cache: " + url); 
                 imageView.setImageBitmap(bitmap); 
         } else { 
                 imageView.setImageBitmap(placeholder); 
                 queueJob(url, imageView, width, height); 
             } 
         } 
      
         private Bitmap downloadBitmap(String url, int width, int height) { 
             try { 
                 Bitmap bitmap = BitmapFactory.decodeStream((InputStream) new URL( 
                         url).getContent()); 
                 bitmap = Bitmap.createScaledBitmap(bitmap, width, height, true); 
                 cache.put(url, new SoftReference<Bitmap>(bitmap)); 
                 return bitmap; 
             } catch (MalformedURLException e) { 
                 e.printStackTrace(); 
             } catch (IOException e) { 
                 e.printStackTrace(); 
             } 
      
             return null; 
         } 
     }