android LocalSocket的使用

需求:

在Activity与另外一个线程中的服务进行数据传递,之前只用的AIDL,但是这个传输是单向的,不满足项目的需求,后来发现了这个LocalSocket.于是自己摸索使用,网上的教程好多都是抄袭的看的不明白.

目标:一个进程与另一个进程间的通信.

// 这个是我启动的服务,在单独的一个进程中执行 process这个属性不是很明白,请百度一下.
<service android:name=".LocalSocketService"
android:process=":server"/>
// 这是另外一种配置,我试了一下,这种方式也是可以实现的.
<service android:name=".LocalSocketService"
android:process="jin.frid.server"/>

public class LocalSocketService extends Service {
public final static String TAG = "LocalSocketService";
public final static String ADDRESS = "/com/jin/kai100";
LocalSocket localSocket;
private LocalServerSocket localServerSocket;

@Override
public void onCreate() {
super.onCreate();
new Thread() {
@Override
public void run() {
try {
LocalServerSocket server = new LocalServerSocket(ADDRESS);

while (true) {
// 这个方法是阻塞的,有Client连接上来的时候,这里就会回调.
final LocalSocket receiver = server.accept();

new Thread() {
@Override
public void run() {
try {
Log.i(TAG, "server sender");
// 读取的是一个阻塞的过程,如果在这里不开一个线程的,那么会一直阻塞在这里,下面的代码得不到执行
InputStream input = receiver.getInputStream();
// 这里是读取的代码
int readed = 0;
byte[] bytes = new byte[1024];
// reading
while (readed != -1) {
// read next byte
readed = input.read(bytes);
Log.i(TAG, "server receive = " +new String(bytes, 0, readed));
}
} catch (IOException e) {
e.printStackTrace();
}
}
}.start();

if (receiver != null) {
// 这里是server发送信息,如果上面的读取阻塞了,就一直执行不到这里,所以上面开了线程处理.
OutputStream outputStream = receiver.getOutputStream();
for (int i = 0; i < 10; i++) {
Thread.sleep(1000);
Log.i(TAG, "server sender");
outputStream.write("haode".getBytes());
// 发送数据必须要在这里写入到输出流中,不然那边是接收不到
// 自己之前就在这里纠结了很久,因为自己之前用的LocalSocket的close()方法之后.另一边才能收到.我想了好久.我以为这个LocalSocket是一个类似短的服务连接.单次有效呢.后来发现自己理解错了
outputStream.flush();
}
}
}
} catch (IOException e) {
Log.e(getClass().getName(), e.getMessage());
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}.start();
}

@Nullable
@Override
public IBinder onBind(Intent intent) {

return null;
}
}

public class MainActivity extends Activity {
private InputStream inputStream;
private OutputStream outputStream;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
}

public void button(View view) {
Intent intent = new Intent(getApplicationContext(), LocalSocketService.class);
startService(intent);
}

LocalSocket localSocket;
public void button2(View view) {

new Thread() {
@Override
public void run() {
localSocket = new LocalSocket();
try {
Log.i("MainActivity", "");
// 连接另外一个进程的Sever连接
// LocalSocketService.ADDRESS 这个是连接的地址,相当于每个连接标示符,你想连接到这个上
localSocket.connect(new LocalSocketAddress(LocalSocketService.ADDRESS));
Log.i("MainActivity", "localSocket.isConnected() = " +localSocket.isConnected());
// 设置接收的缓存空间的大小
localSocket.setReceiveBufferSize(500000);
localSocket.setSendBufferSize(500000);
// 获取连接的输入,输出流.
outputStream = localSocket.getOutputStream();
inputStream = localSocket.getInputStream();
PrintWriter printWriter = new PrintWriter(outputStream);
final BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(inputStream));
// 这里是模拟想服务端发送信息
for (int i = 0; i < 10; i++) {
Thread.sleep(1000);
outputStream.write("client sender".getBytes());
Log.i("MainActivity", "client sender");
printWriter.flush();
}
// 这里启用线程,去读取,因为读取是阻塞操作,会造成问题的.
new Thread(){
@Override
public void run() {
try {
// 这里从本地服务读取信息
int readed = bufferedReader.read();
while (readed != -1) {
// read next byte
readed = bufferedReader.read();
Log.i("MainActivity", "clientRead=" + readed);
}
} catch (IOException e) {
e.printStackTrace();
}
}
}.start();

} catch (IOException e) {
e.printStackTrace();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}.start();
}
/**
这里模拟客服端发送数据
**/
public void button3(View view) {
try {
if (localSocket != null) {
Log.i("MainActivity", "send message");

outputStream.write("haod".getBytes());
outputStream.flush();
}

} catch (IOException e) {
e.printStackTrace();
}
}
// 关闭连接
public void button4(View view) {
if (localSocket != null)
try {
localSocket.close();
} catch (IOException e) {
e.printStackTrace();
}
}

}

总结:LocalSocket 可以像Socket一样,可以双向发送接收.记得发送数据的时候要调用flush()方法,这里是我自己遇到的坑.