Service和Activity之间的交互

   本地服务的交互
1.通过发送广播的方式进行消息传递
实现原理：
   server端当有内容需要传递时，可以发送一条广播，而client端可以注册一个广播接收者去接收广播信息，
   根据内容做相关的操作。
小结：
   通过广播的方式来实现activity和service的交互是非常简单而且容易实现的，一般可以胜任轻量级的应用。
 它的缺点也比较明显，发送的广播会受到系统的制约，系统会优先发送系统广播，在某些特定的情况之下，
 自定义广播的发送会有延迟，就不能即使的收到信息了，而且在广播接受者中不能做耗时操作，会造成ANR异常。

2.文件的共享
 实现原理：
    server可以把传递的信息写入到文件中，然后client端在读取文件信息，显示在界面上。
 小结：
    通过文件共享的方式达成了activity和service的通信，整体来说也比较简单，相当于一个往里写，一个往外读，
  形成了一个通道，但是也是有缺点，当数据量过多时或者说数据结构过于复杂，那么写入和读取就会造成不一致的
  效果，就会造成错误，而且经过了中转站，也比较消耗时间。

实例：

public class MainActivity extends Activity {

	private TextView loadingTv;
	private ProgressBar mBar;
	private Intent intent;
	private SharedPreferences pref;
	Handler handler = new Handler(){
		public void handleMessage(android.os.Message msg) {
			int current = pref.getInt("current", -1);
			if (current>100||current<0) {
				Log.i("tag", "进度值错误");
			}else {
				mBar.setProgress(current);
				loadingTv.setText(current+"%");
				handler.sendEmptyMessageDelayed(1, 1000);
			}
		}
	};
	@Override
	protected void onCreate(Bundle savedInstanceState) {
		super.onCreate(savedInstanceState);
		setContentView(R.layout.activity_main);
		loadingTv = (TextView)findViewById(R.id.loadingTv);
		mBar = (ProgressBar)findViewById(R.id.bar);
		intent = new Intent(this,ShareFileService.class);
		pref = getSharedPreferences("currentLoading", MODE_PRIVATE);
		mBar.setMax(100);
	}
	
	public void start(View view){
		startService(intent);
		
		handler.sendEmptyMessageDelayed(1, 1000);
	}
	
	public void stop(View view){
		stopService(intent);
	}
}

public class ShareFileService extends Service{

	private Timer timer;
	private SharedPreferences preferences;
	private int i = 0;
	@Override
	public void onCreate() {
		super.onCreate();
		
		timer = new Timer();   //定时器
		preferences = getSharedPreferences("currentLoading", MODE_PRIVATE);
		timer.schedule(new MyTimerTask(), 0,1000);
	}
	public void setCurrentLoading(int value){
		preferences.edit().putInt("current", value).commit();
	}
	@Override
	public IBinder onBind(Intent intent) {
		return null;
	}
	
	@Override
	public void onDestroy() {
		super.onDestroy();
		if (timer!=null) {
			timer.cancel();
			timer = null;
		}
	}
	class MyTimerTask extends TimerTask{

		@Override
		public void run() {
			setCurrentLoading(i);
			if (i==100) {
				i=0;
			}
			i++;
		}
		
	}

}
（注册服务）

3.自定义接口：
  实现过程：
    自定义接口，在接口当中写入获取数据的方法，在service当中写一个内部类继承与Binder类同时实现这个接口，
    并且重写获取数据的方法，在方法中返回数据，然后在onBind方法中返回自定义类的对象，
    在activity当中绑定服务，写一个类继承于ServiceConnection，通过onServiceConnected方法得到接口自定义的
    子类的对象，然后调用他的方法，就可以得到service端返回的数据了。
  小结：
    这种写法简单，拓展性强，但是也存在缺点，延迟获取服务器端的消息，无法从0开始同步信息，自定义接口方式

    完成通信只能用于进程间通信，不能用于跨进程通信。

实例：

public class MainActivity extends Activity {
	private TextView loadTV;
	private ProgressBar bar;
	private MyService.MyBind bind;
	private Loading load;
	Handler handler = new Handler() {
		public void handleMessage(android.os.Message msg) {
			if (msg.what == 1) {
				int i = load.getloading();
				bar.setProgress(i);
				loadTV.setText(i + "%");
				handler.sendEmptyMessageDelayed(1, 100);
			}

		};
	};

	@Override
	protected void onCreate(Bundle savedInstanceState) {
		super.onCreate(savedInstanceState);
		setContentView(R.layout.activity_main);

		loadTV = (TextView) findViewById(R.id.loadingTv);
		bar = (ProgressBar) findViewById(R.id.bar);
		bar.setMax(100);
	}

	ServiceConnection conn = new ServiceConnection() {

		@Override
		public void onServiceDisconnected(ComponentName name) {

		}

		@Override
		public void onServiceConnected(ComponentName name, IBinder service) {
			load = (Loading) service;
		}
	};

	public void start(View view) {
		Intent intent = new Intent(this, MyService.class);
		boolean b = bindService(intent, conn, BIND_AUTO_CREATE);
		if (b) {
			Toast.makeText(this, "绑定成功", Toast.LENGTH_SHORT).show();
			handler.sendEmptyMessageDelayed(1, 100);
		} else {
			Toast.makeText(this, "绑定失败", Toast.LENGTH_SHORT).show();

		}

	}

	public void stop(View view) {
		unbindService(conn);
	}
}

public class MyService extends Service {
	private int i = 0;
	private Timer timer;
	private MyTimeTask myTimeTask;

	@Override
	public void onCreate() {
		super.onCreate();
		timer = new Timer();
		myTimeTask = new MyTimeTask();
		timer.scheduleAtFixedRate(myTimeTask, 0, 100);
	}

	@Override
	public IBinder onBind(Intent intent) {
		// TODO Auto-generated method stub
		return new MyBind();
	}

	class MyBind extends Binder implements Loading {
		public MyService getservice() {
			return MyService.this;
		}

		@Override
		public int getloading() {
			// TODO Auto-generated method stub
			return i;
		}
	}

	@Override
	public void onDestroy() {
		super.onDestroy();
		if (timer != null) {
			timer.cancel();
			timer = null;
		}
	}

	public class MyTimeTask extends TimerTask {
		@Override
		public void run() {
			// TODO Auto-generated method stub
			if (i < 100) {
				i++;
			} else {
				i = 100;
			}
		}
	}
}
（注册服务）

public interface Loading {
    int getloading();
}