How to use WCF service in android?

Question

Am new in android and wcf service. I have created one service for insert and hosted here. I know how to use in windows phone but I do not know how to use in android.

here is the service: http://wcfservice.triptitiwari.com/Service1.svc

Please let me know how to use my service function in android.?

Answer 1

To consume a WCF service without using any networking libraries like Retrofit you will need to add ksoap2 as a dependency to your Gradle project. You can download the jar file here

You have to add the jar file to the libs folder in your project libs directory /YourProject/app/libs/ksoap2.jar and then also include this line in your app Gradle file

compile files('libs/ksoap2.jar')

After you included this as a dependency you will have to create the following objects. It does not have to be exactly like my implementation, this is just a version of what it could look like.

---

YourWcfImplementation.java

import android.os.AsyncTask;
import android.support.v4.util.Pair;
import android.util.Log;

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 java.util.List;

public class YourWcfImplementation {
    private static final String TAG = YourWcfImplementation.class.getSimpleName();

    private static final String NAMESPACE = "http://tempuri.org/";
    private static final String URL = "http://wcfservice.triptitiwari.com/Service1.svc";
    private static final String SERVICE_NAME = "IService1";

    private DataProcessingListener dataProcessingListener;

    public YourWcfImplementation(DataProcessingListener dataProcessingListener) {
        this.dataProcessingListener = dataProcessingListener;
    }

    /**
     * Invokes a server request with specified parameters
     * @param serviceTransportEntity
     */
    public void invokeServiceRequest(ServiceTransportEntity serviceTransportEntity) {
        new AsynchronousRequestTask().execute(serviceTransportEntity);
    }

    /**
     * Handles the request processing
     * @param params
     */
    private String processRequest(ServiceTransportEntity params) {
        String methodName = params.getMethodName();

        SoapObject request = new SoapObject(NAMESPACE, methodName);
        String soapAction = NAMESPACE + SERVICE_NAME + "/" + methodName;

        for (Pair<String, String> pair : params.getTransportProperties()) {
            PropertyInfo prop = new PropertyInfo();
            prop.setName(pair.first);
            prop.setValue(pair.second);

            request.addProperty(prop);
        }

        SoapSerializationEnvelope envelope = getSoapSerializationEnvelope(request);

        return executeHttpTransportCall(soapAction, envelope);
    }

    /**
     * Execute the http call to the server
     * @param soapAction
     * @param envelope
     * @return string response
     */
    private String executeHttpTransportCall(String soapAction, SoapSerializationEnvelope envelope) {
        String stringResponse;

        HttpTransportSE androidHttpTransport = new HttpTransportSE(URL);
        try {
            androidHttpTransport.call(soapAction, envelope);

            SoapPrimitive response = (SoapPrimitive)envelope.getResponse();
            stringResponse = String.valueOf(response);
        } catch (Exception e) {
            Log.e(TAG, "ERROR", e);
            stringResponse = e.getMessage();
        }

        return stringResponse;
    }

    /**
     * Builds the serialization envelope
     * @param request
     * @return SoapSerializationEnvelope
     */
    private SoapSerializationEnvelope getSoapSerializationEnvelope(SoapObject request) {
        SoapSerializationEnvelope envelope = new SoapSerializationEnvelope(SoapEnvelope.VER11);
        envelope.dotNet = true;
        envelope.setOutputSoapObject(request);

        return envelope;
    }

    /**
     * Handles asynchronous requests
     */
    private class AsynchronousRequestTask extends AsyncTask<ServiceTransportEntity, String, String> {

        @Override
        protected String doInBackground(ServiceTransportEntity... params) {
            return processRequest(params[0]);
        }

        @Override
        protected void onPostExecute(String response) {
            dataProcessingListener.hasProcessedData(response);
        }
    }

    public interface DataProcessingListener {
        public void hasProcessedData(String data);
    }
}

---

ServiceTransportEntity.java

/**
 * Entity that holds data used in the soap request
 */
public class ServiceTransportEntity {
    private String methodName;
    private List<Pair<String, String>> transportProperties;

    public ServiceTransportEntity(String methodName, List<Pair<String, String>> transportProperties) {
        this.methodName = methodName;
        this.transportProperties = transportProperties;
    }

    public String getMethodName() {
        return methodName;
    }

    public List<Pair<String, String>> getTransportProperties() {
        return transportProperties;
    }
}

---

And then you will just implement that class with code that should look similar to this

List<Pair<String, String>> properties = new ArrayList<>();
properties.add(new Pair<>("PropertyName", "PropertyValue"));

ServiceTransportEntity serviceTransportEntity = new ServiceTransportEntity("SomeMethodName", properties);
YourWcfImplementation wcfImplementation = new YourWcfImplementation(new YourWcfImplementation.DataProcessingListener() {
    @Override
    public void hasProcessedData(String response) {
        //Do something with the response
    }
}).invokeServiceRequest(serviceTransportEntity);

Answer 2

Have a look at retrofit library for android: http://square.github.io/retrofit/

It is really simple to use, and very scalable.

// below is the your client interface for wcf service 

public interface IServer{
    @POST("/GetUserDetails")
    public void getUserDetails(@Body YourRequestClass request
, Callback<YourResponseClass> response);

}

...

// code to below goes in a class

IServer server;

private Client newClient() {
        OkHttpClient okHttpClient = new OkHttpClient();
        okHttpClient.setSslSocketFactory(getSSLSocketFactory());
        return new OkClient(okHttpClient);
}

RestAdapter adapter = new RestAdapter.Builder()
                .setConverter(new GsonConverter(gson))
                .setLogLevel(APIUtils.getLogLevel())
                .setClient(newClient())
                .setEndpoint("wcf service url")
                .build();
this.server = adapter.create(IServer.class);



 ..

Example of usage once is all set up

server.getUserDetails( new YourRequestClass ,new Callback<YourResponseClass>() {
        @Override
        public void success(YourResponseClass yourResponse, Response response) {
            // do something on success
        }

        @Override
        public void failure(RetrofitError error) {
           // do something on error
        }
    });

Below is the libraries you will need:

compile 'com.squareup.retrofit:retrofit:1.9.0'

compile 'com.squareup.okhttp:okhttp-urlconnection:2.0.0'

compile 'com.squareup.okhttp:okhttp:2.0.0'