LifecycleLoggingServiceActivities.java

package edu.vanderbilt.cs282.feisele;

import android.app.Activity;
import android.content.ComponentName;
import android.content.Context;
import android.content.Intent;
import android.content.ServiceConnection;
import android.os.Bundle;
import android.os.IBinder;
import android.view.View;
import android.view.View.OnClickListener;
import android.widget.Button;
import android.widget.Toast;

public class LifecycleLoggingServiceActivities {

	/**
	 * <p>
	 * Example of explicitly starting and stopping the local service. This
	 * demonstrates the implementation of a service that runs in the same
	 * process as the rest of the application, which is explicitly started and
	 * stopped as desired.
	 * </p>
	 * 
	 * <p>
	 * Note that this is implemented as an inner class only keep the sample all
	 * together; typically this code would appear in some separate class.
	 * <p>
	 * Watch for button clicks.
	 */
	public static class Controller extends Activity {
		@Override
		protected void onCreate(Bundle savedInstanceState) {
			super.onCreate(savedInstanceState);

			setContentView(R.layout.lifecycle_service_controller);

			final Button startButton = (Button) findViewById(R.id.start);
			startButton.setOnClickListener(mStartListener);

			final Button stopButton = (Button) findViewById(R.id.stop);
			stopButton.setOnClickListener(mStopListener);
		}

		/**
		 * Make sure the service is started. It will continue running until
		 * someone calls stopService(). The Intent we use to find the service
		 * explicitly specifies our service component, because we want it
		 * running in our own process and don't want other applications to
		 * replace it.
		 */
		private OnClickListener mStartListener = new OnClickListener() {
			public void onClick(View v) {

				startService(new Intent(Controller.this,
						LifecycleLoggingService.class));
			}
		};

		private OnClickListener mStopListener = new OnClickListener() {
			public void onClick(View v) {
				// Cancel a previous call to startService(). Note that the
				// service will not actually stop at this point if there are
				// still bound clients.
				stopService(new Intent(Controller.this,
						LifecycleLoggingService.class));
			}
		};
	}

	// ----------------------------------------------------------------------

	/**
	 * Example of binding and unbinding to the local service. This demonstrates
	 * the implementation of a service which the client will bind to, receiving
	 * an object through which it can communicate with the service.</p>
	 * 
	 * <p>
	 * Note that this is implemented as an inner class only keep the sample all
	 * together; typically this code would appear in some separate class.
	 */
	public static class Binding extends Activity {
		private boolean mIsBound;

		@SuppressWarnings("unused")
		private LifecycleLoggingService mBoundService;

		private ServiceConnection mConnection = new ServiceConnection() {
			/**
			 * This is called when the connection with the service has been
			 * established, giving us the service object we can use to interact
			 * with the service. Because we have bound to a explicit service
			 * that we know is running in our own process, we can cast its
			 * IBinder to a concrete class and directly access it.
			 */
			public void onServiceConnected(ComponentName className,
					IBinder service) {
				mBoundService = ((LifecycleLoggingService.LocalBinder) service)
						.getService();
				Toast.makeText(Binding.this, R.string.local_service_connected,
						Toast.LENGTH_SHORT).show();
			}

			/**
			 * This is called when the connection with the service has been
			 * unexpectedly disconnected -- that is, its process crashed.
			 * Because it is running in our same process, we should never see
			 * this happen.
			 */
			public void onServiceDisconnected(ComponentName className) {

				mBoundService = null;
				Toast.makeText(Binding.this,
						R.string.local_service_disconnected, Toast.LENGTH_SHORT)
						.show();
			}
		};

		/**
		 * Establish a connection with the service. We use an explicit class
		 * name because we want a specific service implementation that we know
		 * will be running in our own process (and thus won't be supporting
		 * component replacement by other applications).
		 */
		void doBindService() {
			bindService(
					new Intent(Binding.this, LifecycleLoggingService.class),
					mConnection, Context.BIND_AUTO_CREATE);
			mIsBound = true;
		}

		void doUnbindService() {
			if (mIsBound) {
				// Detach our existing connection.
				unbindService(mConnection);
				mIsBound = false;
			}
		}

		@Override
		protected void onDestroy() {
			super.onDestroy();
			doUnbindService();
		}

		private OnClickListener mBindListener = new OnClickListener() {
			public void onClick(View v) {
				doBindService();
			}
		};

		private OnClickListener mUnbindListener = new OnClickListener() {
			public void onClick(View v) {
				doUnbindService();
			}
		};

		/**
		 * Watch for button clicks.
		 * 
		 * @param savedInstanceState
		 */
		@Override
		protected void onCreate(Bundle savedInstanceState) {
			super.onCreate(savedInstanceState);

			setContentView(R.layout.lifecycle_service_binding);

			final Button bindButton = (Button) findViewById(R.id.bind);
			bindButton.setOnClickListener(mBindListener);

			final Button unbindButton = (Button) findViewById(R.id.unbind);
			unbindButton.setOnClickListener(mUnbindListener);
		}
	}
}