Pages
RapidFire
10:57 PM
Posted by Mina Samy
APPLICATION: RapidFire. | ![]() | ![]() |
DEVELOPER: Peapple Ltd | ||
CATEGORY: Social | ||
PRICE: Free. | ||
REQUIRES ANDROID: 2.2 and up | ||
CONTENT RATING: Low Maturity |
With RapidFire share your messages and upload multiple photos to multiple social networks including:
WordPress | last.fm | My Space | Tumblr | |||
![]() | ![]() | ![]() | ![]() | ![]() | ![]() | ![]() |
now with RapidFire share your thoughts with the whole world with the whole world with a single click:
![]() |
| share thoughts in one click |
you can send more than 140 characters to all networks including Twitter.
Sign in with your account to 11 social networks:
![]() |
| RapidFire social networks |
RapidFire supports the following networks and blogs:
- Facebook.
- Twitter.
- LinkedIn.
- Tumblr.
- My Space.
- Google Buzz.
- WordPress.
- last. fm.
- Foursquare.
- Friendfeed.
- idetni.ca.
Take photos and include them with your message instantly:
RapidFire supports the following image services:
- YFrog.
- Mobypicture.
Say what you want even from your home screen:
share your thoughts even from your phone's home screen.
Upgrade to the Pro version and enjoy more features:
Geo-tagging: link your posts with your locations:
Ad-free:
And a last word for developers:
RapidFire is an excellent example of the application that can wrap many different APIs and provide an easy way to access them seamlessly. in such a case that you have multiple social networks APIs, it's important to isolate the user from the complications of each one through such an abstraction.
| Reactions: |
Android Developers Blog: New Editing Features in Eclipse plug-in for Android
10:50 AM
Posted by Mina Samy
| Reactions: |
Connecting to a web service over a Secure Sockets Layer (SSL): protocol:
11:56 AM
Posted by Mina Samy
Android default HttpClinet does not support SSL connections, so if you have a secured web service, you need to connect to it via javax.net.ssl.HttpsURLConnection.
if you want to call a SSL SOAP web service:
if you want to call a SSL SOAP web service:
String CallWebService(String url,
String soapAction,
String envelope) throws IOException {
URL address=new URL(url);
URLConnection connection=address.openConnection();
HttpsURLConnection post=(HttpsURLConnection)connection;
post.setDoInput(true);
post.setDoOutput(true);
post.setRequestMethod("POST");
post.setRequestProperty("SOAPAction", soapAction);
post.setRequestProperty( "Content-type", "text/xml; charset=utf-8" );
post.setRequestProperty( "Content-Length", String.valueOf(envelope.length()));
post.setReadTimeout(4000);
OutputStream outStream=post.getOutputStream();
Writer out=new OutputStreamWriter(outStream);
out.write(envelope);
out.flush();
out.close();
InputStream inStream = post.getInputStream();
BufferedInputStream in = new BufferedInputStream(inStream,4);
StringBuffer buffer=new StringBuffer();
// read 4 bytes a time
byte[] buffArray=new byte[4];
int c=0;
while((c=in.read(buffArray))!=-1){
for(int i=0;i<c;i++)
buffer.append((char)buffArray[i]);
}
return buffer.toString();
}
| Reactions: |
Calling SOAP Web Services with Android APIs
10:26 PM
Posted by Mina Samy
One of the most common functionalities required in mobile applications is to call a web service to retrieve data. This process involves requesting the web service with parameters, receiving the response and parsing it to obtain data.
Today the most common web services types are SOAP and REST. Android does not provide a built in SOAP client, there are many third party libraries that can be used, but we'll see how to call a SOAP web service with native android APIs.
Requesting SOAP web service:
Before proceeding to the code, let's take a look at the SOAP structure:Today the most common web services types are SOAP and REST. Android does not provide a built in SOAP client, there are many third party libraries that can be used, but we'll see how to call a SOAP web service with native android APIs.
Requesting SOAP web service:
a soap request can be something like this:
POST /InStock HTTP/1.1
Host: www.example.org
Content-Type: application/soap+xml; charset=utf-8
Content-Length: length
SOAPAction: "http://www.w3schools.com/GetItems"
<?xml version="1.0"?>
<soap:Envelope
xmlns:soap="http://www.w3.org/2001/12/soap-envelope"
soap:encodingStyle="http://www.w3.org/2001/12/soap-encoding">
<soap:Header>
<m:Trans xmlns:m="http://www.w3schools.com/transaction/"
soap:mustUnderstand="1">234
</m:Trans>
</soap:Header>
<soap:Body>
<m:GetPrice xmlns:m="http://www.w3schools.com/prices">
<m:Item>Apples</m:Item>
</m:GetPrice>
</soap:Body></soap:Envelope>
the SOAP request/response is sent as a SOAP Envelope which consists of a SOAP Header and a SOAP Body.
- SOAP Header: optional component of the envelop, contains application specific information, such as authentication.
- SOAP Body: the actual message sent to/received from the service.
- The header can contain a SOAP Action which identifies the desired function to be called by the service.
Calling the service:
First: construct the SOAP envelope manually like this:
String envelope="<?xml version=\"1.0\" encoding=\"utf-8\"?>"+
"<soap:Envelope xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\" xmlns:xsd=\"http://www.w3.org/2001/XMLSchema\" xmlns:soap=\"http://schemas.xmlsoap.org/soap/envelope/\">"+
"<soap:Body>"+
"<GetItems xmlns=\"http://tempuri.org/\">"+
"<startDate>%s</ startDate>"+
"<getAll>%s</getAll>"+
"</Items>"+
"</soap:Body>"+
"</soap:Envelope>";
where %s are place holders where you substitute request parameters in like thisString requestEnvelope=String.format(envelope, "10-5-2011","true");
Second: call the web service like this:
String CallWebService(String url,
String soapAction,
String envelope) {
final DefaultHttpClient httpClient=new DefaultHttpClient();
// request parameters
HttpParams params = httpClient.getParams();
HttpConnectionParams.setConnectionTimeout(params, 10000);
HttpConnectionParams.setSoTimeout(params, 15000);
// set parameter
HttpProtocolParams.setUseExpectContinue(httpClient.getParams(), true);
// POST the envelope
HttpPost httppost = new HttpPost(url);
// add headers
httppost.setHeader("soapaction", soapAction);
httppost.setHeader("Content-Type", "text/xml; charset=utf-8");
String responseString="";
try {
// the entity holds the request
HttpEntity entity = new StringEntity(envelope);
httppost.setEntity(entity);
// Response handler
ResponseHandler rh=new ResponseHandler() {
// invoked when client receives response
public String handleResponse(HttpResponse response)
throws ClientProtocolException, IOException {
// get response entity
HttpEntity entity = response.getEntity();
// read the response as byte array
StringBuffer out = new StringBuffer();
byte[] b = EntityUtils.toByteArray(entity);
// write the response byte array to a string buffer
out.append(new String(b, 0, b.length));
return out.toString();
}
};
responseString=httpClient.execute(httppost, rh);
}
catch (Exception e) {
Log.v("exception", e.toString());
}
// close the connection
httpClient.getConnectionManager().shutdown();
return responseString;
}
after calling this function, you will have the response as a String, something like this:
<?xml version="1.0" encoding="utf-8"?>
<soap:Envelope xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:soap="http://schemas.xmlsoap.org/soap/envelope/">
<soap:Body>
<GetItemsResponse xmlns="http://tempuri.org/">
<GetItemsResult>
<Items>
<Item>
<name>string</name>
<description>string</ description >
</iPhoneCategory>
<iPhoneCategory>
<name>string</name>
<description>string</ description >
</ Item >
</Items>
</GetItemsResult>
</ GetItemsResponse >
</soap:Body>
</soap:Envelope>
this response needs to be parsed to extract the data.
| Reactions: |
Calling REST Web Services with Android.
11:49 AM
Posted by Mina Samy
Requesting REST web service: you request REST web services by calling a URL with the parameters. like this
an example of calling a REST web service:
http://example.com/resources/getitems
an example of calling a REST web service:
String callWebErvice(String serviceURL){
// http get client
HttpClient client=new DefaultHttpClient();
HttpGet getRequest=new HttpGet();
try {
// construct a URI object
getRequest.setURI(new URI(serviceURL));
} catch (URISyntaxException e) {
Log.e("URISyntaxException", e.toString());
}
// buffer reader to read the response
BufferedReader in=null;
// the service response
HttpResponse response=null;
try {
// execute the request
response = client.execute(getRequest);
} catch (ClientProtocolException e) {
Log.e("ClientProtocolException", e.toString());
} catch (IOException e) {
Log.e("IO exception", e.toString());
}
try {
in=new BufferedReader(new InputStreamReader(response.getEntity().getContent()));
} catch (IllegalStateException e) {
Log.e("IllegalStateException", e.toString());
} catch (IOException e) {
Log.e("IO exception", e.toString());
}
StringBuffer buff=new StringBuffer("");
String line="";
try {
while((line=in.readLine())!=null)
{
buff.append(line);
}
} catch (IOException e) {
Log.e("IO exception", e.toString());
return e.getMessage();
}
try {
in.close();
} catch (IOException e) {
Log.e("IO exception", e.toString());
}
// response, need to be parsed
return buff.toString();
}
| Reactions: |
Subscribe to:
Posts (Atom)


























