So rufen Sie einen SOAP-Webdienst unter Android auf [geschlossen]

Ich habe große Probleme, gute Informationen zum Aufrufen eines Standard-SOAP / WSDL-Webdienstes mit Android zu finden. Alles, was ich finden konnte, sind entweder sehr komplizierte Dokumente und Verweise auf "kSoap2" und dann ein bisschen über das manuelle Parsen von allem mit SAX . OK, das ist in Ordnung, aber es ist 2008, also dachte ich mir, dass es eine gute Bibliothek zum Aufrufen von Standard-Webdiensten geben sollte.

Der Webdienst ist im Grunde nur ein in NetBeans erstellter . Ich hätte gerne IDE-Unterstützung für die Generierung der Sanitärklassen. Ich brauche nur die einfachste / eleganteste Möglichkeit, einen WSDL- basierten Webdienst von einem Android-basierten Telefon aus zu kontaktieren .

Android bietet keine SOAP-Bibliothek. Sie können entweder Ihre eigenen schreiben oder so etwas wie kSOAP 2 verwenden . Wie Sie bemerken, konnten andere kSOAP2 in ihren eigenen Projekten kompilieren und verwenden, aber ich musste nicht.

Google hat bisher wenig Interesse daran gezeigt, Android eine SOAP-Bibliothek hinzuzufügen. Mein Verdacht dafür ist, dass sie lieber die aktuellen Trends bei Webdiensten hin zu REST-basierten Diensten unterstützen und JSON als Datenkapselungsformat verwenden. Oder verwenden Sie XMPP für Messaging. Das ist aber nur eine Vermutung.

XML-basierte Webdienste sind derzeit unter Android eine nicht triviale Aufgabe. Da ich NetBeans nicht kenne, kann ich nicht mit den dort verfügbaren Tools sprechen, aber ich stimme zu, dass eine bessere Bibliothek verfügbar sein sollte. Es ist möglich, dass der XmlPullParser Sie vor der Verwendung von SAX bewahrt, aber ich weiß nicht viel darüber.

org.apache.http.impl.client.DefaultHttpClientkommt standardmäßig im Android SDK. Dadurch werden Sie mit der WSDL verbunden.

HttpClient httpClient = new DefaultHttpClient();
HttpContext localContext = new BasicHttpContext();
HttpGet httpGet = new HttpGet("http://www.example.com/" + URL);
HttpResponse response = httpClient.execute(httpGet, localContext);

Es ist wahr, dass SOAP aufgrund seines Overheads nicht die beste Wahl für den Datenaustausch mit mobilen Geräten ist. Möglicherweise befinden Sie sich jedoch in einer Situation, in der Sie das Format der Serverausgabe nicht steuern.

Wenn Sie sich also an SOAP halten müssen, gibt es hier eine für Android gepatchte kSOAP2-Bibliothek:
http://code.google.com/p/ksoap2-android/

Um einen Webdienst von einem mobilen Gerät (insbesondere auf einem Android-Telefon) aus aufzurufen, habe ich eine sehr einfache Methode verwendet. Ich habe keine Webdienst-Client-API verwendet, um den Webdienst aufzurufen. Mein Ansatz ist wie folgt, um einen Anruf zu tätigen.

1. Erstellen Sie eine einfache HTTP-Verbindung mithilfe der Java-Standard-API HttpURLConnection.
2. Bilden Sie eine SOAP-Anfrage. (Sie können SOAPUI helfen, um eine SOAP-Anfrage zu stellen.)
3. Setzen Sie das doOutPut-Flag auf true.
4. Legen Sie HTTP-Header-Werte wie Inhaltslänge, Inhaltstyp und Benutzeragent fest. Vergessen Sie nicht, den Wert für die Inhaltslänge festzulegen, da dieser obligatorisch ist.
5. Schreiben Sie die gesamte SOAP-Anforderung in den Ausgabestream.
6. Rufen Sie die Methode auf, um eine Verbindung herzustellen und die Antwort zu erhalten (in meinem Fall habe ich verwendet getResonseCode).
7. Wenn Ihr Antwortcode als erhalten hat
   200. Dies bedeutet, dass Sie den Webdienst erfolgreich aufrufen können.
8. Nehmen Sie nun einen Eingabestream über dieselbe HTTP-Verbindung und empfangen Sie das Zeichenfolgenobjekt. Dieses Zeichenfolgenobjekt ist eine SOAP-Antwort.
9. Wenn der Antwortcode nicht 200 ist, nehmen Sie einen ErrorInputStream auf demselben HTTP-Objekt und erhalten Sie den Fehler, falls vorhanden.
10. Analysieren Sie die empfangene Antwort mit SAXParser (in meinem Fall) oder DOMParaser oder einem anderen Analysemechanismus.

Ich habe dieses Verfahren für das Android-Telefon implementiert und es wird erfolgreich ausgeführt. Ich kann die Antwort analysieren, auch wenn sie mehr als 700 KB beträgt.

SOAP ist aufgrund des erforderlichen Verarbeitungs- / Analyse-Overheads eine ungeeignete Technologie für die Verwendung auf Android (oder Mobilgeräten im Allgemeinen). Ein REST-Service ist eine leichtere Lösung, und das würde ich vorschlagen. Android wird mit einem SAX-Parser geliefert, dessen Verwendung ziemlich trivial ist. Wenn Sie unbedingt SOAP auf einem mobilen Gerät verarbeiten / analysieren müssen, tut mir das leid. Der beste Rat, den ich anbieten kann, ist, SOAP nicht zu verwenden.

Vor ungefähr einem Jahr habe ich diesen Thread gelesen, um herauszufinden, wie SOAP-Aufrufe unter Android ausgeführt werden. Die Vorschläge, mit HttpClient meine eigenen zu erstellen, haben dazu geführt, dass ich meine eigene SOAP-Bibliothek für Android erstellt habe:

IceSoap

Grundsätzlich können Sie Umschläge erstellen, die über eine einfache Java-API gesendet werden sollen, und diese dann automatisch in Objekte analysieren, die Sie über XPath definieren ... zum Beispiel:

<Dictionary>
    <Id></Id>
    <Name></Name>
</Dictionary>

Wird:

@XMLObject("//Dictionary")
public class Dictionary {
    @XMLField("Id")
    private String id;

    @XMLField("Name")
    private String name;
}

Ich habe es für mein eigenes Projekt verwendet, aber ich dachte, es könnte einigen anderen Menschen helfen, also habe ich einige Zeit damit verbracht, es zu trennen und zu dokumentieren. Ich würde es wirklich lieben, wenn einige Ihrer armen Seelen, die beim Googeln von "SOAP Android" über diesen Thread stolpern, es versuchen und etwas davon profitieren könnten.

VERGESSEN SIE NICHT, ksoap2.jar in Ihrem Projekt hinzuzufügen, und fügen Sie die INTERNET-Berechtigung in der AndroidManifest-Datei hinzu

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.widget.TextView;

public class WebserviceActivity extends Activity {

    private static final String NAMESPACE = "https://api.authorize.net/soap/v1/";
    private static final String URL ="https://apitest.authorize.net/soap/v1/Service.asmx?wsdl"; 
    private static final String SOAP_ACTION = "https://api.authorize.net/soap/v1/AuthenticateTest";
    private static final String METHOD_NAME = "AuthenticateTest";
    private TextView lblResult;


    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.main);

        lblResult = (TextView) findViewById(R.id.tv);

        SoapObject request = new SoapObject(NAMESPACE, METHOD_NAME); 
        request.addProperty("name","44vmMAYrhjfhj66fhJN");
        request.addProperty("transactionKey","9MDQ7fghjghjh53H48k7e7n");
        SoapSerializationEnvelope envelope = new SoapSerializationEnvelope(SoapEnvelope.VER11); 
        envelope.setOutputSoapObject(request);
        HttpTransportSE androidHttpTransport = new HttpTransportSE(URL);
        try {
            androidHttpTransport.call(SOAP_ACTION, envelope);

            //SoapPrimitive  resultsRequestSOAP = (SoapPrimitive) envelope.getResponse();
            // SoapPrimitive  resultsRequestSOAP = (SoapPrimitive) envelope.getResponse();
            SoapObject resultsRequestSOAP = (SoapObject) envelope.bodyIn;


            lblResult.setText(resultsRequestSOAP.toString());
            System.out.println("Response::"+resultsRequestSOAP.toString());


        } catch (Exception e) {
            System.out.println("Error"+e);
        }

    }
}

Ich hatte meine Erfahrung mit KSOAP; Ich habe mich für einen einfacheren Ansatz entschieden.

Erstellen Sie bei einer gegebenen WSDL-Datei SOAP-Anforderungsvorlagen für jede Anforderung (z. B. mithilfe der SOAP-Benutzeroberfläche) und ersetzen Sie dann die im Code zu übergebenden Werte. POSTEN Sie diese Daten mithilfe der DefaultHttpClient-Instanz an den Service-Endpunkt und rufen Sie den Antwortstrom ab. Analysieren Sie den Antwortstrom mit einem XML-Pull-Parser.

Sie können sich WSClient ++ ansehen

Ich habe einen neuen SOAP-Client für die Android-Plattform erstellt. Es wird eine von JAX-WS generierte Schnittstelle verwendet, dies ist jedoch bislang nur ein Proof-of-Concept.

Wenn Sie interessiert sind, versuchen Sie bitte das Beispiel und / oder schauen Sie sich die Quelle bei AndroidSOAP an .

Wenn Sie können, entscheiden Sie sich für JSON. Android wird mit dem kompletten org.json-Paket geliefert

Rufen Sie die ksoap2- Methoden auf. Es funktioniert sehr gut.

Richten Sie die Details wie ein

private static String mNAMESPACE=null;
private static String mURL=null;
public static Context context=null;
SoapSerializationEnvelope envelope = new SoapSerializationEnvelope(SoapEnvelope.VER11);
envelope.dotNet = true;
envelope.setOutputSoapObject(Request);

envelope.addMapping(mNAMESPACE, "UserCredentials",new UserCredendtials().getClass());
AndroidHttpTransport androidHttpTransport = new AndroidHttpTransport(mURL);

und dann, um das Ergebnis zu erhalten, tun

androidHttpTransport.call(SOAP_ACTION, envelope);
result = (SoapPrimitive)envelope.getResponse();

Ich hoffe, das Aufrufen eines Webdienstes von Android hilft.

Vor ein paar Monaten habe ich mit dem jax-ws-Webdienst in der j2ee-Anwendung gearbeitet. Dort haben wir CXF wsdl2java verwendet, um einen WS-Client-Stub aus der WSDL-Datei zu generieren, und mit diesen Client-Stubs haben wir die Webdienste verwendet. Vor ein paar Wochen, als ich versuchte, den Webdienst auf die gleiche Weise auf der Android-Plattform zu nutzen, konnte ich das nicht, weil das Android-Glas nicht alle "jax-ws" -Unterstützungsklassen enthält. Dieses Mal habe ich kein solches Tool gefunden (wenn ich nicht effizient googeln konnte), um meine Anforderungen zu erfüllen -

• Holen Sie sich den Client-Stub aus der WSDL.
• Rufen Sie den Service mit einem Argument auf (Java Business Request Object).
• Holen Sie sich das Response Business Object.

Also habe ich mein eigenes Android SOAP Client Generation Tool entwickelt . Wo müssen Sie diese Schritte ausführen:

• Fügen Sie WSDL Get WS Client Stub in Ihr Projekt ein.
• Sagen Sie für einen Dienst "ComplexOperationService", instanziieren Sie den Dienst, rufen Sie den Endpoint-Port ab, rufen Sie die Dienstmethode auf und erhalten Sie die Antwort vom Webdienst:

z.B:

ComplexOperationService service = new ComplexOperationService( );
ComplexOperation port= service.getComplexOperationPort();    
SomeComplexRequest request = --Get some complex request----;    
SomeComplexResp resp = port.operate( request  );

• Sie müssen sich nicht um die Serviceklasse / req / response-Klassen oder andere Klassen und die Methode kümmern, da Sie wissen, dass alles aus WSDL generiert wird.
• Und natürlich müssen Sie sich der Seifenaktion / des Umschlags / des Namespace usw. nicht bewusst sein. Rufen Sie die Methode einfach so auf, wie wir Entwickler es ständig tun.

Ich bin sicher, Sie könnten mit Axis einen kleinen SOAP-Client erstellen . Installationsanweisungen für die Achse .

Ich denke, Call SOAP Web Service von Android-Anwendung wird Ihnen sehr helfen.

Befolgen Sie diese Schritte mit der Methode SOAP

Aus der WSDL-Datei

• Erstellen Sie SOAP-Anforderungsvorlagen für jede Anforderung.

• Ersetzen Sie dann die Werte, die im Code übergeben werden sollen.

• POSTEN Sie diese Daten mithilfe der DefaultHttpClient-Instanz an den Service-Endpunkt.

• Holen Sie sich den Antwort-Stream und schließlich

• Analysieren Sie den Antwortstrom mit einem XML-Pull-Parser.

Wenn Sie JSON verwenden können, gibt es ein Whitepaper, ein Video und den Beispielcode unter Entwickeln von Anwendungsdiensten mit PHP-Servern und Android-Telefonclients .

Für mich ist es am einfachsten, mit einem guten Tool alle erforderlichen Klassen zu generieren. Persönlich benutze ich diese Seite:

http://easywsdl.com/

Es unterstützt recht komplexe Webdienste und verwendet ksoap2.

Ich würde vorschlagen, ein sehr nützliches Tool auszuprobieren, das mir sehr geholfen hat. Die Leute, die sich um dieses Projekt kümmern, waren auch sehr hilfreich. www.wsdl2code.com/

Wenn Sie Probleme beim Aufrufen des Webdienstes in Android haben, können Sie den folgenden Code verwenden, um den Webdienst aufzurufen und eine Antwort zu erhalten. Stellen Sie sicher , dass Ihr der Webdienst die Antwort in das Rückdatentabellenformat .this Code wird Ihnen helfen , wenn Sie Daten aus der Verwendung von SQL Server - Datenbank. Wenn Sie MYSQL verwenden , müssen Sie eines ändern , indem Sie einfach das Wort NewDataSet aus dem Satz obj2=(SoapObject) obj1.getProperty("NewDataSet");durch DocumentElement ersetzen

void callWebService(){ 

private static final String NAMESPACE = "http://tempuri.org/"; // for wsdl it may be package name i.e http://package_name
private static final String URL = "http://localhost/sample/services/MyService?wsdl";
// you can use IP address instead of localhost
private static final String METHOD_NAME = "Function_Name";
private static final String SOAP_ACTION = "urn:" + METHOD_NAME;

    SoapObject request = new SoapObject(NAMESPACE, METHOD_NAME);
    request.addProperty("parm_name", prm_value);// Parameter for Method
    SoapSerializationEnvelope envelope = new SoapSerializationEnvelope(SoapEnvelope.VER11);
    envelope.dotNet = true;// **If your Webservice in .net otherwise remove it**
    envelope.setOutputSoapObject(request);
    HttpTransportSE androidHttpTransport = new HttpTransportSE(URL);

    try {
        androidHttpTransport.call(SOAP_ACTION, envelope);// call the eb service
                                                                                                         // Method
    } catch (Exception e) {
        e.printStackTrace();
    }

    // Next task is to get Response and format that response
    SoapObject obj, obj1, obj2, obj3;
    obj = (SoapObject) envelope.getResponse();
    obj1 = (SoapObject) obj.getProperty("diffgram");
    obj2 = (SoapObject) obj1.getProperty("NewDataSet");

    for (int i = 0; i < obj2.getPropertyCount(); i++) { 
// the method getPropertyCount() and  return the number of rows
            obj3 = (SoapObject) obj2.getProperty(i);
            obj3.getProperty(0).toString();// value of column 1
            obj3.getProperty(1).toString();// value of column 2
            // like that you will get value from each column
        }
    }

Wenn Sie diesbezüglich ein Problem haben, können Sie mir schreiben.

Bitte laden Sie die SOAP-Bibliotheksdatei herunter und fügen Sie sie mit Ihrem Projekt hinzu. Dateiname: ksoap2-android-assembly-3.4.0-jar-with-dependencies

Reinigen Sie die Anwendung und starten Sie das Programm

Hier ist der Code für den SOAP-Serviceabruf

    String SOAP_ACTION = "YOUR_ACTION_NAME";
    String METHOD_NAME = "YOUR_METHOD_NAME";
    String NAMESPACE = "YOUR_NAME_SPACE";
    String URL = "YOUR_URL";
    SoapPrimitive resultString = null;

    try {
        SoapObject Request = new SoapObject(NAMESPACE, METHOD_NAME);
        addPropertyForSOAP(Request);

        SoapSerializationEnvelope soapEnvelope = new SoapSerializationEnvelope(SoapEnvelope.VER11);
        soapEnvelope.dotNet = true;
        soapEnvelope.setOutputSoapObject(Request);

        HttpTransportSE transport = new HttpTransportSE(URL);

        transport.call(SOAP_ACTION, soapEnvelope);
        resultString = (SoapPrimitive) soapEnvelope.getResponse();

        Log.i("SOAP Result", "Result Celsius: " + resultString);
    } catch (Exception ex) {
        Log.e("SOAP Result", "Error: " + ex.getMessage());
    }
    if(resultString != null) {
        return resultString.toString();
    }
    else{
        return "error";
    }

Die Ergebnisse können JSONObject oder JSONArray oder String sein

Für Ihre bessere Referenz, https://trinitytuts.com/load-data-from-soap-web-service-in-android-application/

Vielen Dank.

Dies ist ein funktionierendes Beispiel für die Nutzung von SOAP-Webdiensten in Android.

** Hinweis :: *** VERGESSEN SIE NICHT, ksoap2.jar in Ihrem Projekt hinzuzufügen und fügen Sie auch die INTERNET-Berechtigung in der AndroidManifest-Datei hinzu *

public final String WSDL_TARGET_NAMESPACE = "http://tempuri.org/";
public final String METHOD_NAME = "FahrenheitToCelsius";
public final String PROPERTY_NAME = "Fahrenheit";
public final String SOAP_ACTION = "http://tempuri.org/FahrenheitToCelsius";
public final String SOAP_ADDRESS = "http://www.w3schools.com/webservices/tempconvert.asmx";


private class TestAsynk extends AsyncTask<String, Void, String> {

    @Override
    protected void onPostExecute(String result) {

        super.onPostExecute(result);
        Toast.makeText(getApplicationContext(),
                String.format("%.2f", Float.parseFloat(result)),
                Toast.LENGTH_SHORT).show();
    }

    @Override
    protected String doInBackground(String... params) {
        SoapObject request = new SoapObject(WSDL_TARGET_NAMESPACE,
                METHOD_NAME);
        request.addProperty(PROPERTY_NAME, params[0]);

        SoapSerializationEnvelope envelope = new SoapSerializationEnvelope(
                SoapEnvelope.VER11);
        envelope.dotNet = true;

        envelope.setOutputSoapObject(request);

        HttpTransportSE androidHttpTransport = new HttpTransportSE(
                SOAP_ADDRESS);
        Object response = null;
        try {

            androidHttpTransport.call(SOAP_ACTION, envelope);
            response = envelope.getResponse();
            Log.e("Object response", response.toString());

        } catch (Exception e) {
            e.printStackTrace();
        }
        return response.toString();
    }
}

Sie können einen Seifenaufruf als Post über http mit bestimmten Headern ausführen. Ich habe diese Frage ohne zusätzliche Bibliotheken wie ksoap2 gelöst. Hier ist Live-Code, der Bestellungen vom Seifenservice erhält

private static HashMap<String,String> mHeaders = new HashMap<>();

static {
    mHeaders.put("Accept-Encoding","gzip,deflate");
    mHeaders.put("Content-Type", "application/soap+xml");
    mHeaders.put("Host", "35.15.85.55:8080");
    mHeaders.put("Connection", "Keep-Alive");
    mHeaders.put("User-Agent","AndroidApp");
    mHeaders.put("Authorization","Basic Q2xpZW50NTkzMzppMjR3s2U="); // optional
}public final static InputStream receiveCurrentShipments(String stringUrlShipments)
{
    int status=0;
    String xmlstring= "<soap:Envelope xmlns:soap=\"http://www.w3.org/2003/05/soap-envelope\" xmlns:ser=\"http://35.15.85.55:8080/ServiceTransfer\">\n" +
            "   <soap:Header/>\n" +
            "   <soap:Body>\n" +
            "      <ser:GetAllOrdersOfShipment>\n" +
            "         <ser:CodeOfBranch></ser:CodeOfBranch>\n" +
            "      </ser:GetAllOrdersOfShipment>\n" +
            "   </soap:Body>\n" +
            "</soap:Envelope>";
    StringBuffer chaine = new StringBuffer("");

    HttpURLConnection connection = null;
    try {
        URL url = new URL(stringUrlShipments);
        connection = (HttpURLConnection) url.openConnection();
        connection.setRequestProperty("Content-Length", xmlstring.getBytes().length + "");
        connection.setRequestProperty("SOAPAction", "http://35.15.85.55:8080/ServiceTransfer/GetAllOrdersOfShipment");

        for(Map.Entry<String, String> entry : mHeaders.entrySet()) {
            String key = entry.getKey();
            String value = entry.getValue();
            connection.setRequestProperty(key,value);

        }

        connection.setRequestMethod("POST");
        connection.setDoInput(true);

        OutputStream outputStream = connection.getOutputStream();
        outputStream.write(xmlstring.getBytes("UTF-8"));
        outputStream.close();

        connection.connect();
        status = connection.getResponseCode();
    } catch (ProtocolException e) {
        e.printStackTrace();
    } catch (MalformedURLException e) {
        e.printStackTrace();
    } catch (IOException e) {
        e.printStackTrace();
    } finally {

        Log.i("HTTP Client", "HTTP status code : " + status);
    }

    InputStream inputStream = null;
    try {
        inputStream = connection.getInputStream();
    } catch (IOException e) {
        e.printStackTrace();
    }

    return inputStream;
}

Versuchen Sie, diesen Client zu verwenden, um einen SOAP-Webdienst von Android aus aufzurufen

VERGESSEN SIE NICHT, ksoap2-android.jar in Ihren Java-Build-Pfad einzufügen

public class WsClient {
    private static final String SOAP_ACTION = "somme";
    private static final String OPERATION_NAME = "somme";
    private static final String WSDL_TARGET_NAMESPACE = "http://example.ws";
    private static final String SOAP_ADDRESS = "http://192.168.1.2:8080/axis2/services/Calculatrice?wsdl";

    public String caclculerSomme() {

        String res = null;
        SoapObject request = new SoapObject(WSDL_TARGET_NAMESPACE,
                OPERATION_NAME);
        request.addProperty("a", "5");
        request.addProperty("b", "2");

        SoapSerializationEnvelope envelope = new SoapSerializationEnvelope(
                SoapEnvelope.VER11);
        envelope.dotNet = true;
        envelope.setOutputSoapObject(request);
        HttpTransportSE httpTransport = new HttpTransportSE(SOAP_ADDRESS);

        try {
            httpTransport.call(SOAP_ACTION, envelope);
            String result = envelope.getResponse().toString();
            res = result;
            System.out.println("############# resull is :" + result);
        } catch (Exception exception) {
            System.out.println("########### ERRER" + exception.getMessage());
        }

        return res;
    }
}

Seife Libaray hinzufügen (ksoap2-android-assembly-3.2.0-jar-with-dependencies.jar ) :

öffentliche statische Zeichenfolge Fn_Confirm_CollectMoney_Approval (

        HashMap < String, String > str1,
        HashMap < String, String > str2,
        HashMap < String, String > str3) {

    Object response = null;
    String METHOD_NAME = "CollectMoney";
    String NAMESPACE = "http://xxx/yyy/xxx";
    String URL = "http://www.w3schools.com/webservices/tempconvert.asmx";
    String SOAP_ACTION = "";

    try {

        SoapObject RequestParent = new SoapObject(NAMESPACE, METHOD_NAME);

        SoapObject Request1 = new SoapObject(NAMESPACE, "req");

        PropertyInfo pi = new PropertyInfo();

        Set mapSet1 = (Set) str1.entrySet();

        Iterator mapIterator1 = mapSet1.iterator();

        while (mapIterator1.hasNext()) {

            Map.Entry mapEntry = (Map.Entry) mapIterator1.next();

            String keyValue = (String) mapEntry.getKey();

            String value = (String) mapEntry.getValue();

            pi = new PropertyInfo();

            pi.setNamespace("java:com.xxx");

            pi.setName(keyValue);

            pi.setValue(value);

            Request1.addProperty(pi);
        }

        mapSet1 = (Set) str3.entrySet();

        mapIterator1 = mapSet1.iterator();

        while (mapIterator1.hasNext()) {

            Map.Entry mapEntry = (Map.Entry) mapIterator1.next();

            // getKey Method of HashMap access a key of map
            String keyValue = (String) mapEntry.getKey();

            // getValue method returns corresponding key's value
            String value = (String) mapEntry.getValue();

            pi = new PropertyInfo();

            pi.setNamespace("java:com.xxx");

            pi.setName(keyValue);

            pi.setValue(value);

            Request1.addProperty(pi);
        }

        SoapObject HeaderRequest = new SoapObject(NAMESPACE, "XXX");

        Set mapSet = (Set) str2.entrySet();

        Iterator mapIterator = mapSet.iterator();

        while (mapIterator.hasNext()) {

            Map.Entry mapEntry = (Map.Entry) mapIterator.next();

            // getKey Method of HashMap access a key of map
            String keyValue = (String) mapEntry.getKey();

            // getValue method returns corresponding key's value
            String value = (String) mapEntry.getValue();

            pi = new PropertyInfo();

            pi.setNamespace("java:com.xxx");

            pi.setName(keyValue);

            pi.setValue(value);

            HeaderRequest.addProperty(pi);
        }

        Request1.addSoapObject(HeaderRequest);

        RequestParent.addSoapObject(Request1);

        SoapSerializationEnvelope soapEnvelope = new SoapSerializationEnvelope(
                SoapEnvelope.VER10);

        soapEnvelope.dotNet = false;

        soapEnvelope.setOutputSoapObject(RequestParent);

        HttpTransportSE transport = new HttpTransportSE(URL, 120000);

        transport.debug = true;

        transport.call(SOAP_ACTION, soapEnvelope);

        response = (Object) soapEnvelope.getResponse();

        int cols = ((SoapObject) response).getPropertyCount();

        Object objectResponse = (Object) ((SoapObject) response)
                .getProperty("Resp");

        SoapObject subObject_Resp = (SoapObject) objectResponse;


        modelObject = new ResposeXmlModel();

        String MsgId = subObject_Resp.getProperty("MsgId").toString();


        modelObject.setMsgId(MsgId);

        String OrgId = subObject_Resp.getProperty("OrgId").toString();


        modelObject.setOrgId(OrgId);

        String ResCode = subObject_Resp.getProperty("ResCode").toString();


        modelObject.setResCode(ResCode);

        String ResDesc = subObject_Resp.getProperty("ResDesc").toString();


        modelObject.setResDesc(ResDesc);

        String TimeStamp = subObject_Resp.getProperty("TimeStamp")
                .toString();


        modelObject.setTimestamp(ResDesc);

        return response.toString();

    } catch (Exception ex) {

        ex.printStackTrace();

        return null;
    }

}