Develop Reference

Android doesn't kill bound service

I am creating bound service for socket connection.Which means it is creating a long polling connection and listens my server.If user closes the app in task manager my service is killing i have no problem with this.But when user presses the back button I am calling activity.finish() method for close app.But with this method my service doesn't kill,it is still connected to socket server.
Is this normal ? And Could be this drain the battery ?
My service:
public class SocketService extends Service {
//you need constants to tell servise and activity what you are sending a message for
public static final int REGISTER_CHAT_ACTIVITY = 1;
public static final int MESSAGE_RECEIVED = 2;
final Messenger mMessenger = new Messenger(new IncomingHandler());
Messenger chat;
private Socket socket;
#Override
public void onCreate() {
try {
socket = IO.socket("ip");
socket.on(Socket.EVENT_CONNECT, new Emitter.Listener() {
#Override
public void call(Object... args) {
}
}).on("connected", new Emitter.Listener() {
#Override
public void call(Object... args) {
}
}).on("message", new Emitter.Listener() {
#Override
public void call(Object... args) {
try {
chat.send(android.os.Message.obtain(null, MESSAGE_RECEIVED, args[0]));
} catch (RemoteException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
});
//and add all the other on listeners here
socket.connect();
} catch (URISyntaxException e) {
e.printStackTrace();
}
}
#Override
public int onStartCommand(Intent intent, int flags, int startId) {
if (socket != null) {
socket.disconnect();
socket.connect();
} else {
try {
socket = IO.socket("ip");
socket.connect();
} catch (URISyntaxException e) {
e.printStackTrace();
}
}
return START_STICKY;
}
#Override
public IBinder onBind(Intent intent) {
return mMessenger.getBinder();
}
class IncomingHandler extends Handler {
#Override
public void handleMessage(android.os.Message msg) {
switch(msg.what){
case REGISTER_CHAT_ACTIVITY:
chat = msg.replyTo;
break;
}
}
}
public class LocalBinder extends Binder {
SocketService getService() {
return SocketService.this;
}
}
}

I had something similar a while ago i solved the issue by using shared preferences.(Note: I dont think it's the best answer but it solved my problem)
I saved in preferences a boolean to register when i dont need the service anymore but lost reference of it.
public class YourService extends Service {
private YourService serv;
#Override
public void onCreate() {
// TODO Auto-generated method stub
super.onCreate();
serv = this;
Then Somehwere on your code that the service does frequently.
if(!sharedPref.getBoolean("TurnOffService", false)){
serv.stopSelf();
}
Hope it helps.

Android kills the service very frequently

We prepared an Android application with a service that maintains MQTT connection with our server. The service returns a *START_STICKY* from its onStartCommand in order for Android to restart the service in case it kills the service for resource shortages. But the problem is, the service is killed very frequently by Android OS. It sometimes kills the service once in few seconds, even if no other process works on the device(with 2GB of ram). Why Android is killing my service so frequently? How can I lessen the number of restarts? My service should be killed as less as possible, because it disconnects my tcp connection and client have to reconnect again, causing quite a big load on our server. What can be wrong with this code? Thanks
public class GTAndroidMQTTService extends Service implements MqttCallback {
private void init() {
this.clientId = Settings.System.getString(getContentResolver(), Secure.ANDROID_ID);
}
#Override
#Deprecated
public void onStart(Intent intent, int startId) {
logger("onStart() called");
super.onStart(intent, startId);
}
#Override
public int onStartCommand(Intent intent, int flags, int startId) {
logger("onStartCommand() called");
if (client == null) {
try {
init();
conOpt = new MqttConnectOptions();
conOpt.setCleanSession(false);
conOpt.setUserName("...");
conOpt.setPassword("...");
try {
char[] keystorePass = getString(R.string.keystorepass).toCharArray();
KeyStore keyStore = KeyStore.getInstance("BKS");
keyStore.load(getApplicationContext().getResources().openRawResource(R.raw.prdkey),
keystorePass);
TrustManagerFactory trustManagerFactory = TrustManagerFactory
.getInstance(KeyManagerFactory.getDefaultAlgorithm());
trustManagerFactory.init(keyStore);
KeyManagerFactory kmf = KeyManagerFactory.getInstance(KeyManagerFactory
.getDefaultAlgorithm());
kmf.init(keyStore, keystorePass);
SSLContext sslContext = SSLContext.getInstance("TLS");
sslContext.init(kmf.getKeyManagers(), trustManagerFactory.getTrustManagers(), null);
conOpt.setSocketFactory(sslContext.getSocketFactory());
} catch (Exception ea) {
}
client = new MqttClient(this.mqttURL, clientId, new MqttDefaultFilePersistence(folder));
client.setCallback(this);
conOpt.setKeepAliveInterval(this.keepAliveSeconds);
} catch (MqttException e) {
e.printStackTrace();
} catch (NoSuchAlgorithmException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (UnsupportedEncodingException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
if (intent == null) {
Log.i("TAG", "Android restarted the service[START_STICKY]");
if (client != null) {
tryToEstablishConnection();
}
}
return START_STICKY;
}
public void unsubscribe(String topicName) throws MqttException {
try {
client.unsubscribe(topicName);
} catch (Exception e) {
Log.i("TAG", "Unsubscribing from topic \"" + topicName + "has failed: " + e.toString());
}
}
private void retry() {
try {
notifyUserWithServiceStatus("Status Changed", "Status", "Connecting");
client.connect(conOpt);
notifyUserWithServiceStatus("Status Changed", "Status", "User Connected #" + (++retrycnt));
} catch (Exception e) {
notifyUserWithServiceStatus("Status Changed", "Status", "Cannot Connect");
e.printStackTrace();
}
}
public void subscribe(String topicName, int qos) throws MqttException {
try {
client.subscribe(topicName, qos);
} catch (Exception e) {
}
}
public void disconnect() {
try {
client.disconnect();
} catch (MqttException e) {
e.printStackTrace();
}
}
#Override
public IBinder onBind(Intent intent) {
logger("onBind() called");
return null;
}
#Override
public void onCreate() {
logger("onCreate() called");
super.onCreate();
}
#Override
public void connectionLost(Throwable arg0) { // Connection lost
notifyUserWithServiceStatus("Status Changed", "Status", "Connection Lost!");
tryToEstablishConnection();
}
private void tryToEstablishConnection() {
if (!retrying) {
retrying = true;
new Thread(new Runnable() {
#Override
public void run() {
for (;;) {
try {
if (isOnline() && !isConnected()) {
retry();
Thread.sleep(RETRY_INTERVAL);
} else if (isConnected()) {
retrying = false;
break;
} else if (!isOnline()) {
retrying = false;
break;
}
} catch (Exception e) {
e.printStackTrace();
}
}
}
}).start();
}
}
private class NetworkConnectionIntentReceiver extends BroadcastReceiver {
#Override
public void onReceive(Context ctx, Intent intent) {
PowerManager pm = (PowerManager) getSystemService(POWER_SERVICE);
WakeLock wl = pm.newWakeLock(PowerManager.PARTIAL_WAKE_LOCK, "MQTT");
wl.acquire();
if (isOnline() && !isConnected())
notifyUserWithServiceStatus("Status Changed", "Status", "Online but not connected");
else if (!isOnline())
notifyUserWithServiceStatus("Status Changed", "Status", "Connection Lost!");
tryToEstablishConnection();
wl.release();
}
}
private boolean isConnected() {
try {
return client.isConnected();
} catch (Exception e) {
return false;
}
}
private boolean isOnline() {
ConnectivityManager conMgr = (ConnectivityManager) getSystemService(Context.CONNECTIVITY_SERVICE);
NetworkInfo i = conMgr.getActiveNetworkInfo();
if (i == null)
return false;
if (!i.isConnected())
return false;
if (!i.isAvailable())
return false;
return true;
}
#Override
public void onDestroy() {
logger("onDestroy() called");
try {
client.disconnect();
Log.i("TAG", "Service stopped");
} catch (MqttException e) {
e.printStackTrace();
}
super.onDestroy();
}
#Override
public void deliveryComplete(IMqttDeliveryToken arg0) {
// TODO Auto-generated method stub
}
}

It sounds as though your service is running in the Application process; is it directly tied to your Activity?
You'll want to run it a different process entirely; you can do this by adding the following declaration in your manifest:
<service
android:name=".ServiceClassName"
android:process=":yourappname_background" >
And then use the same android:process attribute for any receiver declarations as well.

Does binding to your service keep it alive?

Some Background:
When you create a service you have to make sure your work is started in a background thread. IntentService runs on a background thread while a Service runs on the Main Thread.
A service runs in the main thread of the application that hosts it, by default
Source: http://developer.android.com/guide/components/services.html
Take a look at http://developer.android.com/guide/components/services.html#ExtendingIntentService
Read below for similar issues.
Similar answer in: Service vs IntentService
The Service can be used in tasks with no UI, but shouldn't be too long. If you need to perform long tasks, you must use threads within Service.
Also I would suggest reading CommonsWare's answer to How to always run a service in the background?
My Suggestion:
I would move to an IntentService or WakefulIntentService and consider updating information with an fixed interval instead of using a constant tcp connection. A HTTP based API could provide same information over SSL.

Sending message to an unbound Service in onCreate() method

I am developing an application and I need that when I leave the application (onPause ()) send a message to the service, using a bundle to save some data of my application. It works great. My problem is that when the application starts, it executes the method onCreate (), in this method I use the following code to establish the connection between the application and the service:
MyActivity.java
// This takes care of make the connection
this.getApplicationContext().startService(intent);
this.bindService(intent, mConnectionCallback, Context.BIND_AUTO_CREATE);
/** I need restore the bundle that is in the service, thus i'm sending a message */
Message msg = Message.obtain();
try {
Bundle bundle = new Bundle();
msg.setData(bundle);
msg.what = MyService.REQUEST_BUNDLE;
msg.replyTo = mMessageDispatcher;
mServiceConnection.send(msg);
} catch (RemoteException e) {
e.printStackTrace();
}
The problem is that when you send the message, the connection will still not be established and thus this will throw a NullPointerException. And i dont know how manage this. To be clear my app is just a simple time-tracker and when the user exits the application, I want the time to be saved in a bundle in the service. Is there a way to send the message, right after establishing the connection?
Some of you will say: - "Just send the message after establishing the connection in method onServiceConnected (ComponentName className, IBinder service) of your callback ServiceConnection". But the problem is that I have separated the activity from the API implementation of the service. Here is the complete code of my classes:
ServiceManager.java
public class ServiceManager extends Service {
private NotificationManager mNM;
protected HashMap<Integer, Method> magicSwitch = new HashMap<Integer, Method>();
public ServiceManager() {
try {
for (Method method : Class
.forName(getClass().getCanonicalName())
.getMethods()) {
if (method.isAnnotationPresent(ExecutesWhen.class)) {
try {
ExecutesWhen a = method.getAnnotation(ExecutesWhen.class);
magicSwitch.put(a.what(), method);
Log.d("AkrasiaService","AkrasiaService now knows how handle a "+method.getName()+" with id="+a.what());
} catch (Throwable ex) {
ex.printStackTrace();
}
}
}
} catch (SecurityException e) {
e.printStackTrace();
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
}
class ServiceHandler extends Handler {
#Override
public void handleMessage(Message msg) {
Log.d("AkrasiaService","The service is going to manage a message from the client with what="+msg.what);
try {
Method met = magicSwitch.get(msg.what);
if (met == null) {
throw new NonExistingWhatException();
} else {
met.invoke(ServiceManager.this, msg);
}
} catch (IllegalArgumentException e) {
e.printStackTrace();
} catch (IllegalAccessException e) {
e.printStackTrace();
} catch (InvocationTargetException e) {
e.printStackTrace();
}
}
}
/**
* Target we publish for clients to send messages to IncomingHandler.
*/
final Messenger mMessageInBox = new Messenger(new ServiceHandler());
/**
* Sends a message to the replyTo client.
* #param replyTo: The <code>Messenger</code> to reply the message.
* #param what: The what (subject).
* #param bundle: A data bundle that will go attached to the message.
*/
protected void sendMessageToClient(Messenger replyTo, int what, Bundle bundle) {
try {
Message msg = Message.obtain(null,
what, 0, 0);
msg.setData(bundle);
replyTo.send(msg);
} catch (RemoteException e) {
e.printStackTrace();
}
}
#Override
public IBinder onBind(Intent intent) {
return mMessageInBox.getBinder();
}
#Override
public void onCreate() {
mNM = (NotificationManager)getSystemService(NOTIFICATION_SERVICE);
showNotification();
}
/**
* Show a notification while this service is running.
*/
private void showNotification() {
//Here we immplement the notification
}
}
AkrasiaService.java (my concrete service)
public class AkrasiaService extends ServiceManager {
public final static int TRACKER_APP_BACKUP_REFRESH = 0;
public final static int TRACKER_APP_BACKUP_RETRIVE = 1;
public Bundle mTrackerBackupBundle;
public AkrasiaService() {
super();
}
/** This are the handlers of the request from the client application. The
* annotation ExecuteWhen specifies which method must handle one determined request.
* It uses the "what" annotation attribute like discriminative. */
#ExecutesWhen(what = AkrasiaService.TRACKER_APP_BACKUP_REFRESH)
public void trackerBundleRefresh(Message msg) {
mTrackerBackupBundle = msg.getData();
}
#ExecutesWhen(what = AkrasiaService.TRACKER_APP_BACKUP_RETRIVE)
public void trackerBundleRetrive(Message msg) {
sendMessageToClient(msg.replyTo, AkrasiaService.TRACKER_APP_BACKUP_RETRIVE, mTrackerBackupBundle);
}
//Test
#ExecutesWhen(what = AkrasiaService.FOO)
public void fooResponse(Message msg) {
Bundle bundle = new Bundle();
bundle.putString("test", "Test value");
sendMessageToClient(msg.replyTo, AkrasiaService.FOO, bundle);
}
}
AnnotatedHandler.java
public class AnnotatedHandler extends Handler {
protected HashMap<Integer, Method> magicSwitch = new HashMap<Integer, Method>();
public AnnotatedHandler() {
try {
for (Method method : this.getClass().getMethods() ) {
if (method.isAnnotationPresent(ExecutesWhen.class)) {
try {
ExecutesWhen a = method
.getAnnotation(ExecutesWhen.class);
magicSwitch.put(a.what(), method);
Log.d("AnnotatedHandler","AnnotatedHandler now knows how handle a "+method.getName()+" and id"+a.what());
} catch (Throwable ex) {
ex.printStackTrace();
}
}
}
} catch (SecurityException e) {
e.printStackTrace();
}
}
#Override
public void handleMessage(Message msg) {
try {
Log.d("AnnotatedHandler","The service is going to manage a message from the client with what="+msg.what);
Method met = magicSwitch.get(msg.what);
if (met == null) {
throw new NonExistingWhatException();
} else {
met.invoke(AnnotatedHandler.this, msg);
}
} catch (IllegalArgumentException e) {
e.printStackTrace();
} catch (IllegalAccessException e) {
e.printStackTrace();
} catch (InvocationTargetException e) {
e.printStackTrace();
}
}
}
ServiceClient.java (My service api implementation)
public class ServiceClient {
/** Messenger for communicating with service. */
Messenger mServiceConnection = null;
/** Flag indicating whether we have called bind on the service. */
private boolean mIsBound = false;
private Messenger mMessageDispatcher;
/**
* Class for interacting with the main interface of the service. This callback
* takes care of setup <code>mServiceConnection</code> and therefore, start to
* talk with the service.
*/
private ServiceConnection mConnectionCallback = new ServiceConnection() {
public void onServiceConnected(ComponentName className,
IBinder service) {
mServiceConnection = new Messenger(service);
Log.d("AkrasiaService","The application is connected to the service now!");
mIsBound = true;
}
public void onServiceDisconnected(ComponentName className) {
mServiceConnection = null;
}
};
/**
* This method makes the binding between the service and the client application.
* #param intent: An intent of the concrete implementation of the <code>ServiceManager</code>
* #param activity: The Activity thats want communicate with the service.
*/
public void doBindService(Intent intent, Activity activity) {
Log.d("AkrasiaService","The application is trying to bind to the service...");
activity.getApplicationContext().startService(intent);
activity.bindService(intent, mConnectionCallback, Context.BIND_AUTO_CREATE);
}
public void doUnbindService(Activity activity) {
if (mIsBound) {
activity.unbindService(mConnectionCallback);
mIsBound = false;
}
}
/**
* This method sends a single message to the service.
* #param what: The what (subject) of the message.
*/
public void sendMessage(int what) {
Message msg = Message.obtain();
try {
Bundle bundle = new Bundle();
msg.setData(bundle);
msg.what = what;
msg.replyTo = mMessageDispatcher;
Log.d("AkrasiaService","The application is going to send a message to the service");
mServiceConnection.send(msg);
} catch (RemoteException e) {
e.printStackTrace();
}
}
/**
* This method sends a message to the service with a bundle attached.
* #param what: The what (subject) of the message.
* #param bundle: The data bundle attached to the message.
*/
public void sendMessage(int what, Bundle bundle) {
Message msg = Message.obtain();
try {
msg.setData(bundle);
msg.what = what;
msg.replyTo = mMessageDispatcher;
mServiceConnection.send(msg);
} catch (RemoteException e) {
e.printStackTrace();
}
}
public void setIncomingHandler(Handler handler) {
mMessageDispatcher = new Messenger(handler);
}
public boolean isConnected() {
return mIsBound;
}
}
MainActivity.java (the Activity of my Tracker app)
public class MainActivity extends SherlockFragmentActivity {
private ActionBar mActionBar;
private Tab mStatTab;
private Tab mTrackerTab;
private ServiceClient mClientServiceAPI;
/**
* Handler of incoming messages from service.
*/
public class MyHandler extends AnnotatedHandler {
#ExecutesWhen(what = AkrasiaService.TRACKER_APP_BACKUP_RETRIVE)
public void handleBackupRestore(Message msg) {
Log.d("Client","Handling a message");
Bundle bundle = msg.getData();
if ((bundle != null) && (!bundle.isEmpty())) {
Long timeStamp = bundle.getLong("last-time");
Long chrometerTime = bundle.getLong("chrometer-time");
Chronometer chrometer = (Chronometer) findViewById(R.id.chronometer);
//We add the time between the timestamp and now to the chorometer base
Long now = Calendar.getInstance().getTimeInMillis();
chrometerTime = now - timeStamp + chrometerTime;
chrometer.setBase(chrometerTime);
}
}
};
#Override
public void onCreate(Bundle savedInstanceState) {
setTheme(com.actionbarsherlock.R.style.Sherlock___Theme);
super.onCreate(savedInstanceState);
// Notice that setContentView() is not used, because we use the root
// android.R.id.content as the container for each fragment
// try {
// DatabaseFixture.populateDatabase();
// } catch (NumberFormatException e) {
// // TODO Auto-generated catch block
// e.printStackTrace();
// } catch (ParseException e) {
// // TODO Auto-generated catch block
// e.printStackTrace();
// }
ApplicationContext.getInstance().setMainActivity(this);
ApplicationContext.getInstance().setupPreferences();
sherlockActionBarSetup();
}
private void sherlockActionBarSetup() {
mActionBar = getSupportActionBar();
mActionBar.setNavigationMode(ActionBar.NAVIGATION_MODE_TABS);
mActionBar.setDisplayShowTitleEnabled(false);
mActionBar.setDisplayShowHomeEnabled(false);
TabListener<TrackerFragment> trackerTabListener = new TabListener<TrackerFragment>(this,
"tracker", TrackerFragment.class);
mTrackerTab = mActionBar.newTab().setText("Track").setTabListener(trackerTabListener);
mActionBar.addTab(mTrackerTab);
TabListener<StatFragment> statTabListener = new TabListener<StatFragment>(this, "stats",
StatFragment.class);
mStatTab = mActionBar.newTab().setText("Stats").setTabListener(statTabListener);
mActionBar.addTab(mStatTab);
}
public void sendBackupToTheService() {
Log.d("Client","We are going to make a backup of the chromnometer");
Chronometer chrometer = (Chronometer) findViewById(R.id.chronometer);
Bundle bundle = new Bundle();
bundle.putLong("last-time", Calendar.getInstance().getTimeInMillis());
bundle.putLong("chrometer-time", chrometer.getBase());
bundle.putBoolean("deprecated", false);
mClientServiceAPI.sendMessage(AkrasiaService.TRACKER_APP_BACKUP_REFRESH, bundle);
}
#Override
protected void onPause() {
super.onPause();
sendBackupToTheService();
mClientServiceAPI.doUnbindService(this);
}
#Override
protected void onStop() {
super.onStop();
mClientServiceAPI.doUnbindService(this);
}
public void restarBackupFromService(View view) {
mClientServiceAPI.sendMessage(AkrasiaService.TRACKER_APP_BACKUP_RETRIVE);
}
#Override
protected void onDestroy() {
super.onDestroy();
mClientServiceAPI.doUnbindService(this);
}
#Override
public void onResume() {
super.onResume();
//Sadly this behavior can't be exported to ServiceClient.
//This from below used to be in onResume method
Log.d("Client","We are going to connect to the service");
mClientServiceAPI = new ServiceClient();
mClientServiceAPI.setIncomingHandler(new MyHandler());
Intent intent = new Intent(AkrasiaService.class.getName());
mClientServiceAPI.doBindService(intent,this);
}
/*
* Apparently you can't just tie the callback to the fragment from:
* http://stackoverflow.com/a/6271637/147072
*/
public void triggerClick(View view) {
TrackerFragment fragment = (TrackerFragment)getSupportFragmentManager().findFragmentByTag(
"tracker");
fragment.triggerClick(view);
}
public void saveTimeClick(View view) {
TrackerFragment fragment = (TrackerFragment)getSupportFragmentManager().findFragmentByTag(
"tracker");
try {
fragment.saveTimeClick(view);
} catch (ParseException e) {
e.printStackTrace();
}
// We reload the StatFragment this is to refresh the Graph of the
// StatFragment
mActionBar.removeTab(mStatTab);
TabListener<StatFragment> statTabListener = new TabListener<StatFragment>(this, "stats",
StatFragment.class);
mStatTab = mActionBar.newTab().setText("Stats").setTabListener(statTabListener);
mActionBar.addTab(mStatTab);
}
public void discardTimeClick(View view) {
TrackerFragment fragment = (TrackerFragment)getSupportFragmentManager().findFragmentByTag(
"tracker");
fragment.discardTimeClick(view);
}
How you can see in the MainActivity.java in the onResume method i'm doing the binding between the app and the service, this calls the doBindService(Intent,Activity) method of the ServiceClient.java, and this one do the real binding.
I've been thinking about saving the block of code that sends the message to the service within an instance of the class Method, and send it to the api for this run it on your onServiceConnected method, but I think there must be a better way.
Any suggestions will be appreciated.

Android AVD unable to notice JmDNS services

I've had some difficulty getting JmDNS to work with my Android AVD. I've created 3 applications. An Android application which registers a ServiceListener and logs any activity, A Java application which does the same as the android application, and another Java application which registers a service. The Java listener application will pick up on the other Java application, however the android application will not. I've also tried running two AVD simultaneously to see if they'd pick up on each other and they don't. I should also mention that I have permissions for INTERNET and CHANGE_WIFI_MULSTICAST_STATE enabled. Here's my code:
Android Application:
public class BonjourActivity extends Activity {
// Multicast
private WifiManager wifi;
private MulticastLock lock;
private JmDNS jmdns;
private String type = "_im._tcp.local.";
private ServiceListener listener;
private ServiceInfo serviceInfo;
// On Create
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.main);
// Multicast
wifi = (WifiManager) getSystemService(Context.WIFI_SERVICE);
lock = wifi.createMulticastLock("");
lock.setReferenceCounted(true);
lock.acquire();
// JmDNS
new AsyncTask<Object, Object, Object>(){
#Override
protected Object doInBackground(Object... params) {
// Create JmDNS
try {
jmdns = JmDNS.create();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
return null;
}
protected void onPostExecute(Object result) {
// Add Listener
jmdns.addServiceListener(type, listener = new ServiceListener(){
#Override
public void serviceAdded(ServiceEvent ev) {
jmdns.requestServiceInfo(ev.getType(), ev.getName(), 1);
}
#Override
public void serviceRemoved(ServiceEvent ev) {
Log.d("Service", "Service Removed: " + ev.getName());
}
#Override
public void serviceResolved(ServiceEvent ev) {
Log.d("Service", "Service Resolved: " + ev.getInfo().getURL());
}
});
}
}.execute();
}
// On Destroy
public void onDestroy(){
// Release Lock
if (lock != null){
lock.release();
}
// Close JmDNS
if (jmdns != null){
jmdns.removeServiceListener(type, listener);
try {
jmdns.close();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
super.onDestroy();
}
}
Java Listener Application:
public class Listener {
private static JmDNS jmdns;
private static String type = "_im._tcp.local.";
private static ServiceListener serviceListener;
private static ServiceInfo serviceInfo;
// Main
public static void main(String args[]){
try {
jmdns = JmDNS.create();
jmdns.addServiceListener(type, serviceListener = new ServiceListener(){
#Override
public void serviceAdded(ServiceEvent ev) {
System.out.println("Service Added: " + ev.getName());
jmdns.requestServiceInfo(ev.getType(), ev.getName(), 1);
}
#Override
public void serviceRemoved(ServiceEvent ev) {
System.out.println("Service Removed: " + ev.getName());
}
#Override
public void serviceResolved(ServiceEvent ev) {
System.out.println("Service Resolved: " + ev.getInfo().getURL());
}
});
System.out.println("Listener Added");
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
Java Sender Application:
public class Sender {
private static JmDNS jmdns;
private static String type = "_im._tcp.local.";
private static ServiceListener serviceListener;
private static ServiceInfo serviceInfo;
// Main
public static void main(String args[]){
try {
jmdns = JmDNS.create();
serviceInfo = ServiceInfo.create(type, "Test IM Service", 55555, "Instant messaging test service");
jmdns.registerService(serviceInfo);
System.out.println("Sender: Service Created");
new Timer().schedule(new TimerTask(){
#Override
public void run() {
// TODO Auto-generated method stub
System.out.println("Closing..");
jmdns.unregisterAllServices();
try {
jmdns.close();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
System.exit(0);
}
}, 10000);
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
In Addition, LogCat gives me a few errors when I attempt to run the application:
NetworkManagementSocketTagger setKernelCountSet(10009,0) failed with errno -2
WifiStateMachine Error! unhandled message{ what=131157 when=-1ms }
Might anyone know why the android application is unable to pick up on JmDNS services generated by other applications?

Just a little notice, The virtual device running in the emulator is not in the same network as the computer. Service discovery may not work. My implementation of jmdns does not work in the emulator. Try it on a real device.
And go to http://home.heeere.com/tech-androidjmdns.html for more details.

Android service thread making web request is blocking UI

First I will explain the current situation.
I've 2 different threads in 2 services(read from usb port service and make web requests service). I'm starting them in onCreate of my activity like:
serialServiceIntent = new Intent(NDKSerialActivity.this, SerialService.class);
startService(serialServiceIntent);
webServiceIntent = new Intent(NDKSerialActivity.this, RecordWebService.class);
startService(webServiceIntent);
There is nothing wrong with serial service but in RecordWebService when I make a request my gui stops until response comes.
The code is like that:
public class RecordWebService extends Service
{
public static final String SERVER_ADDRESS = "http://192.168.1.100:8080/MobilHM/rest";
private static final String TAG = RecordWebService.class.getSimpleName();
private RecordWebThread recordWebThread;
#Override
public void onStart(Intent intent, int startId)
{
super.onStart(intent, startId);
recordWebThread = new RecordWebThread(true);
recordWebThread.start();
}
#Override
public void onDestroy()
{
super.onDestroy();
Log.i(TAG, "RecordWebService Destroyed");
}
#Override
public IBinder onBind(Intent intent)
{
return null;
}
}
and
public class RecordWebThread extends Thread
{
private static final String TAG = RecordWebThread.class.getSimpleName();
public boolean always;
public RecordWebThread(boolean always)
{
this.always = always;
}
#Override
public void run()
{
PatientRecord patientRecord = new PatientRecord();
while (always)
{
RestClient restClient = new RestClient(RecordWebService.SERVER_ADDRESS + "/hello");
try
{
restClient.execute(RequestMethod.GET);
}
catch (Exception e1)
{
Log.e(TAG, "", e1);
}
Log.i(TAG, "Server Response Code:->" + restClient.getResponseCode());
Log.i(TAG, "Server Response:->" + restClient.getResponse());
try
{
sleep(4 * 1000);
}
catch (InterruptedException e)
{
Log.e(TAG, "Web service interrupted", e);
}
}
}
}
Also I've tried to remove sleep part and make the thread to run with timer and timer task like:
public void sendRecord()
{
scanTask = new TimerTask()
{
public void run()
{
handler.post(new Runnable()
{
public void run()
{
RestClient restClient = new RestClient(RecordWebService.SERVER_ADDRESS + "/hello");
try
{
restClient.execute(RequestMethod.GET);
}
catch (Exception e1)
{
Log.e(TAG, "", e1);
}
Log.i(TAG, "Server Response Code:->" + restClient.getResponseCode());
Log.i(TAG, "Server Response:->" + restClient.getResponse());
}
});
}
};
t.schedule(scanTask, 1000, 4000);
}
but no luck, my gui hangs when it comes to restClient.execute .
You can find RestClient.java # http://www.giantflyingsaucer.com/blog/?p=1462
How can I make my requests not block my gui thread?
Edit:
public void sendRecord()
{
scanTask = new TimerTask()
{
public void run()
{
RestClient restClient = new RestClient(RecordWebService.SERVER_ADDRESS + "/hello");
try
{
restClient.execute(RequestMethod.GET);
}
catch (Exception e1)
{
Log.e(TAG, "", e1);
}
Log.i(TAG, "Server Response Code:->" + restClient.getResponseCode());
Log.i(TAG, "Server Response:->" + restClient.getResponse());
}
};
t.schedule(scanTask, 1000, 4000);
}
Without handler, I call this in onCreate of my activity but still ui hanging.

Or you can use an IntentService which will handle the thread issues for you.
This is an example class:
public class MyService extends IntentService {
public MyService() {
super("MyService");
}
public MyService(String name) {
super(name);
}
#Override
protected void onHandleIntent(Intent arg0) {
//Do what you want
}
}
Then you just call:
Intent intent = new Intent(getApplicationContext(),MyService.class);
startService(intent);
Edit:
To repeat the same thing every 4 seconds you should do something like this:
PendingIntent serviceIntent= PendingIntent.getService(context,
0, new Intent(context, MyService.class), 0);
long firstTime = SystemClock.elapsedRealtime();
AlarmManager am = (AlarmManager)context.getSystemService(Context.ALARM_SERVICE);
long intervalInSec = 4;
am.setRepeating(AlarmManager.ELAPSED_REALTIME, firstTime, intervalInSec*1000, serviceIntent)
;

In your code (2d version) happens next: You create thread, and it asks UI thread to do some net interaction. Just exclude handler.post(...) while executing request. Later you can use this for simple runnable for updating your UI with results of request.