下面列出了怎么用android.net.LocalSocket的API类实例代码及写法,或者点击链接到github查看源代码。
private LocalSocket connectService() {
LocalSocket socket = new LocalSocket();
boolean done = false;
// The uncrypt socket will be created by init upon receiving the
// service request. It may not be ready by this point. So we will
// keep retrying until success or reaching timeout.
for (int retry = 0; retry < SOCKET_CONNECTION_MAX_RETRY; retry++) {
try {
socket.connect(new LocalSocketAddress(UNCRYPT_SOCKET,
LocalSocketAddress.Namespace.RESERVED));
done = true;
break;
} catch (IOException ignored) {
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
Slog.w(TAG, "Interrupted:", e);
}
}
}
if (!done) {
Slog.e(TAG, "Timed out connecting to uncrypt socket");
return null;
}
return socket;
}
/**
* Constructs instance from connected socket.
*
* @param socket non-null; connected socket
* @param abiList non-null; a list of ABIs this zygote supports.
* @throws IOException
*/
ZygoteConnection(LocalSocket socket, String abiList) throws IOException {
mSocket = socket;
this.abiList = abiList;
mSocketOutStream
= new DataOutputStream(socket.getOutputStream());
mSocketReader = new BufferedReader(
new InputStreamReader(socket.getInputStream()), 256);
mSocket.setSoTimeout(CONNECTION_TIMEOUT_MILLIS);
try {
peer = mSocket.getPeerCredentials();
} catch (IOException ex) {
Log.e(TAG, "Cannot read peer credentials", ex);
throw ex;
}
isEof = false;
}
private BluetoothSocket acceptSocket(String remoteAddr) throws IOException {
BluetoothSocket as = new BluetoothSocket(this);
as.mSocketState = SocketState.CONNECTED;
FileDescriptor[] fds = mSocket.getAncillaryFileDescriptors();
if (DBG) Log.d(TAG, "socket fd passed by stack fds: " + Arrays.toString(fds));
if (fds == null || fds.length != 1) {
Log.e(TAG, "socket fd passed from stack failed, fds: " + Arrays.toString(fds));
as.close();
throw new IOException("bt socket acept failed");
}
as.mPfd = new ParcelFileDescriptor(fds[0]);
as.mSocket = LocalSocket.createConnectedLocalSocket(fds[0]);
as.mSocketIS = as.mSocket.getInputStream();
as.mSocketOS = as.mSocket.getOutputStream();
as.mAddress = remoteAddr;
as.mDevice = BluetoothAdapter.getDefaultAdapter().getRemoteDevice(remoteAddr);
return as;
}
@Override
public void run() {
boolean deleteResult = new File(PATH).delete();
VayLog.d(TAG, "run() delete file = " + deleteResult);
if (!initServerSocket()) {
return;
}
while (isRunning) {
try {
final LocalSocket socket = serverSocket.accept();
// handle socket
handleLocalSocket(socket);
} catch (Exception e) {
VayLog.e(TAG, "Error when accept socket", e);
app.track(e);
initServerSocket();
}
}
}
/**
* init server socket
*
* @return init failed return false.
*/
private boolean initServerSocket() {
// if not running, do not init
if (!isRunning) {
return false;
}
try {
LocalSocket localSocket = new LocalSocket();
localSocket.bind(new LocalSocketAddress(PATH, LocalSocketAddress.Namespace.FILESYSTEM));
serverSocket = new LocalServerSocket(localSocket.getFileDescriptor());
return true;
} catch (IOException e) {
VayLog.e(TAG, "unable to bind", e);
return false;
}
}
@Override
public void run() {
boolean deleteFlag = new File(PATH).delete();
VayLog.d(TAG, "run() delete file = " + deleteFlag);
if (!initServerSocket()) {
return;
}
while (isRunning) {
try {
final LocalSocket socket = serverSocket.accept();
// handle local socket
handleLocalSocket(socket);
} catch (IOException e) {
VayLog.e(TAG, "Error when accept socket", e);
app.track(e);
initServerSocket();
}
}
}
/**
* init server socket
*
* @return init failed return false.
*/
private boolean initServerSocket() {
// if not running, do not init
if (!isRunning) {
return false;
}
try {
LocalSocket localSocket = new LocalSocket();
localSocket.bind(new LocalSocketAddress(PATH, LocalSocketAddress.Namespace.FILESYSTEM));
serverSocket = new LocalServerSocket(localSocket.getFileDescriptor());
return true;
} catch (IOException e) {
VayLog.e(TAG, "unable to bind", e);
app.track(e);
return false;
}
}
@Override
public void run() {
boolean deleteResult = new File(PATH).delete();
VayLog.d(TAG, "run() delete file = " + deleteResult);
if (!initServerSocket()) {
return;
}
while (isRunning) {
try {
final LocalSocket socket = serverSocket.accept();
// handle socket
handleLocalSocket(socket);
} catch (Exception e) {
VayLog.e(TAG, "Error when accept socket", e);
ShadowsocksApplication.app.track(e);
initServerSocket();
}
}
}
/**
* init server socket
*
* @return init failed return false.
*/
private boolean initServerSocket() {
// if not running, do not init
if (!isRunning) {
return false;
}
try {
LocalSocket localSocket = new LocalSocket();
localSocket.bind(new LocalSocketAddress(PATH, LocalSocketAddress.Namespace.FILESYSTEM));
serverSocket = new LocalServerSocket(localSocket.getFileDescriptor());
return true;
} catch (IOException e) {
VayLog.e(TAG, "unable to bind", e);
return false;
}
}
@Override
public void run() {
boolean deleteFlag = new File(PATH).delete();
VayLog.d(TAG, "run() delete file = " + deleteFlag);
if (!initServerSocket()) {
return;
}
while (isRunning) {
try {
final LocalSocket socket = serverSocket.accept();
// handle local socket
handleLocalSocket(socket);
} catch (IOException e) {
VayLog.e(TAG, "Error when accept socket", e);
ShadowsocksApplication.app.track(e);
initServerSocket();
}
}
}
/**
* init server socket
*
* @return init failed return false.
*/
private boolean initServerSocket() {
// if not running, do not init
if (!isRunning) {
return false;
}
try {
LocalSocket localSocket = new LocalSocket();
localSocket.bind(new LocalSocketAddress(PATH, LocalSocketAddress.Namespace.FILESYSTEM));
serverSocket = new LocalServerSocket(localSocket.getFileDescriptor());
return true;
} catch (IOException e) {
VayLog.e(TAG, "unable to bind", e);
ShadowsocksApplication.app.track(e);
return false;
}
}
@Override
protected void onSecured(LocalSocket socket) throws IOException {
LeakyBufferedInputStream leakyIn = new LeakyBufferedInputStream(
socket.getInputStream(),
SENSING_BUFFER_SIZE);
if (mHandlers.isEmpty()) {
throw new IllegalStateException("No handlers added");
}
for (int i = 0, N = mHandlers.size(); i < N; i++) {
HandlerInfo handlerInfo = mHandlers.get(i);
leakyIn.mark(SENSING_BUFFER_SIZE);
boolean matches = handlerInfo.magicMatcher.matches(leakyIn);
leakyIn.reset();
if (matches) {
LogUtil.d("Matches!" + handlerInfo.handler.getClass().getSimpleName());
SocketLike socketLike = new SocketLike(socket, leakyIn);
handlerInfo.handler.onAccepted(socketLike);
return;
}
}
throw new IOException("No matching handler, firstByte=" + leakyIn.read());
}
private static void enforcePermission(Context context, LocalSocket peer)
throws IOException, PeerAuthorizationException {
Credentials credentials = peer.getPeerCredentials();
int uid = credentials.getUid();
int pid = credentials.getPid();
if (LogUtil.isLoggable(Log.VERBOSE)) {
LogUtil.v("Got request from uid=%d, pid=%d", uid, pid);
}
String requiredPermission = Manifest.permission.DUMP;
int checkResult = context.checkPermission(requiredPermission, pid, uid);
if (checkResult != PackageManager.PERMISSION_GRANTED) {
throw new PeerAuthorizationException(
"Peer pid=" + pid + ", uid=" + uid + " does not have " + requiredPermission);
}
}
@Override
protected void onSecured(LocalSocket socket) throws IOException {
LeakyBufferedInputStream leakyIn = new LeakyBufferedInputStream(
socket.getInputStream(),
SENSING_BUFFER_SIZE);
if (mHandlers.isEmpty()) {
throw new IllegalStateException("No handlers added");
}
for (int i = 0, N = mHandlers.size(); i < N; i++) {
HandlerInfo handlerInfo = mHandlers.get(i);
leakyIn.mark(SENSING_BUFFER_SIZE);
boolean matches = handlerInfo.magicMatcher.matches(leakyIn);
leakyIn.reset();
if (matches) {
SocketLike socketLike = new SocketLike(socket, leakyIn);
handlerInfo.handler.onAccepted(socketLike);
return;
}
}
throw new IOException("No matching handler, firstByte=" + leakyIn.read());
}
private static void enforcePermission(Context context, LocalSocket peer)
throws IOException, PeerAuthorizationException {
Credentials credentials = peer.getPeerCredentials();
int uid = credentials.getUid();
int pid = credentials.getPid();
if (LogUtil.isLoggable(Log.VERBOSE)) {
LogUtil.v("Got request from uid=%d, pid=%d", uid, pid);
}
String requiredPermission = Manifest.permission.DUMP;
int checkResult = context.checkPermission(requiredPermission, pid, uid);
if (checkResult != PackageManager.PERMISSION_GRANTED) {
throw new PeerAuthorizationException(
"Peer pid=" + pid + ", uid=" + uid + " does not have " + requiredPermission);
}
}
public void init() {
try {
localLoop = new LocalServerSocket("videoserver");
localReceiver = new LocalSocket();
localReceiver.connect(localLoop.getLocalSocketAddress());
localReceiver.setReceiveBufferSize(LOCAL_BUFF_SIZE);
localReceiver.setSendBufferSize(LOCAL_BUFF_SIZE);
localSender = localLoop.accept();
localSender.setReceiveBufferSize(LOCAL_BUFF_SIZE);
localSender.setSendBufferSize(LOCAL_BUFF_SIZE);
Log.d(LOG_TAG, "Done: init()");
}catch(IOException e) {
Log.e(LOG_TAG, "Error in initializing local socket: " + e);
}
}
@Override
protected void onSecured(LocalSocket socket) throws IOException {
LeakyBufferedInputStream leakyIn = new LeakyBufferedInputStream(
socket.getInputStream(),
SENSING_BUFFER_SIZE);
if (mHandlers.isEmpty()) {
throw new IllegalStateException("No handlers added");
}
for (int i = 0, N = mHandlers.size(); i < N; i++) {
HandlerInfo handlerInfo = mHandlers.get(i);
leakyIn.mark(SENSING_BUFFER_SIZE);
boolean matches = handlerInfo.magicMatcher.matches(leakyIn);
leakyIn.reset();
if (matches) {
SocketLike socketLike = new SocketLike(socket, leakyIn);
handlerInfo.handler.onAccepted(socketLike);
return;
}
}
throw new IOException("No matching handler, firstByte=" + leakyIn.read());
}
private static void enforcePermission(Context context, LocalSocket peer)
throws IOException, PeerAuthorizationException {
Credentials credentials = peer.getPeerCredentials();
int uid = credentials.getUid();
int pid = credentials.getPid();
if (LogUtil.isLoggable(Log.VERBOSE)) {
LogUtil.v("Got request from uid=%d, pid=%d", uid, pid);
}
String requiredPermission = Manifest.permission.DUMP;
int checkResult = context.checkPermission(requiredPermission, pid, uid);
if (checkResult != PackageManager.PERMISSION_GRANTED) {
throw new PeerAuthorizationException(
"Peer pid=" + pid + ", uid=" + uid + " does not have " + requiredPermission);
}
}
protected void createSockets() throws IOException {
final String LOCAL_ADDR = "net.majorkernelpanic.streaming-";
for (int i=0;i<10;i++) {
try {
mSocketId = new Random().nextInt();
mLss = new LocalServerSocket(LOCAL_ADDR+mSocketId);
break;
} catch (IOException e1) {}
}
mReceiver = new LocalSocket();
mReceiver.connect( new LocalSocketAddress(LOCAL_ADDR+mSocketId));
mReceiver.setReceiveBufferSize(500000);
mReceiver.setSoTimeout(3000);
mSender = mLss.accept();
mSender.setSendBufferSize(500000);
}
public LegacyVpnRunner(VpnConfig config, String[] racoon, String[] mtpd) {
super(TAG);
mConfig = config;
mDaemons = new String[] {"racoon", "mtpd"};
// TODO: clear arguments from memory once launched
mArguments = new String[][] {racoon, mtpd};
mSockets = new LocalSocket[mDaemons.length];
// This is the interface which VPN is running on,
// mConfig.interfaze will change to point to OUR
// internal interface soon. TODO - add inner/outer to mconfig
// TODO - we have a race - if the outer iface goes away/disconnects before we hit this
// we will leave the VPN up. We should check that it's still there/connected after
// registering
mOuterInterface = mConfig.interfaze;
if (!TextUtils.isEmpty(mOuterInterface)) {
final ConnectivityManager cm = ConnectivityManager.from(mContext);
for (Network network : cm.getAllNetworks()) {
final LinkProperties lp = cm.getLinkProperties(network);
if (lp != null && lp.getAllInterfaceNames().contains(mOuterInterface)) {
final NetworkInfo networkInfo = cm.getNetworkInfo(network);
if (networkInfo != null) mOuterConnection.set(networkInfo.getType());
}
}
}
IntentFilter filter = new IntentFilter();
filter.addAction(ConnectivityManager.CONNECTIVITY_ACTION);
mContext.registerReceiver(mBroadcastReceiver, filter);
}
private static boolean openLmkdSocket() {
try {
sLmkdSocket = new LocalSocket(LocalSocket.SOCKET_SEQPACKET);
sLmkdSocket.connect(
new LocalSocketAddress("lmkd",
LocalSocketAddress.Namespace.RESERVED));
sLmkdOutputStream = sLmkdSocket.getOutputStream();
} catch (IOException ex) {
Slog.w(TAG, "lowmemorykiller daemon socket open failed");
sLmkdSocket = null;
return false;
}
return true;
}
private ZygoteState(LocalSocket socket, DataInputStream inputStream,
BufferedWriter writer, List<String> abiList) {
this.socket = socket;
this.inputStream = inputStream;
this.writer = writer;
this.abiList = abiList;
}
/**
* Attempt to connect to a remote device.
* <p>This method will block until a connection is made or the connection
* fails. If this method returns without an exception then this socket
* is now connected.
* <p>Creating new connections to
* remote Bluetooth devices should not be attempted while device discovery
* is in progress. Device discovery is a heavyweight procedure on the
* Bluetooth adapter and will significantly slow a device connection.
* Use {@link BluetoothAdapter#cancelDiscovery()} to cancel an ongoing
* discovery. Discovery is not managed by the Activity,
* but is run as a system service, so an application should always call
* {@link BluetoothAdapter#cancelDiscovery()} even if it
* did not directly request a discovery, just to be sure.
* <p>{@link #close} can be used to abort this call from another thread.
*
* @throws IOException on error, for example connection failure
*/
public void connect() throws IOException {
if (mDevice == null) throw new IOException("Connect is called on null device");
try {
if (mSocketState == SocketState.CLOSED) throw new IOException("socket closed");
IBluetooth bluetoothProxy =
BluetoothAdapter.getDefaultAdapter().getBluetoothService(null);
if (bluetoothProxy == null) throw new IOException("Bluetooth is off");
mPfd = bluetoothProxy.getSocketManager().connectSocket(mDevice, mType,
mUuid, mPort, getSecurityFlags());
synchronized (this) {
if (DBG) Log.d(TAG, "connect(), SocketState: " + mSocketState + ", mPfd: " + mPfd);
if (mSocketState == SocketState.CLOSED) throw new IOException("socket closed");
if (mPfd == null) throw new IOException("bt socket connect failed");
FileDescriptor fd = mPfd.getFileDescriptor();
mSocket = LocalSocket.createConnectedLocalSocket(fd);
mSocketIS = mSocket.getInputStream();
mSocketOS = mSocket.getOutputStream();
}
int channel = readInt(mSocketIS);
if (channel <= 0) {
throw new IOException("bt socket connect failed");
}
mPort = channel;
waitSocketSignal(mSocketIS);
synchronized (this) {
if (mSocketState == SocketState.CLOSED) {
throw new IOException("bt socket closed");
}
mSocketState = SocketState.CONNECTED;
}
} catch (RemoteException e) {
Log.e(TAG, Log.getStackTraceString(new Throwable()));
throw new IOException("unable to send RPC: " + e.getMessage());
}
}
public void run() {
try {
for (;;) {
LocalServerSocket serverSocket = Server.this.mServerSocket;
if (serverSocket == null) {
break;
}
LocalSocket socket = serverSocket.accept();
if (Log.isLoggable("InstantRun", 2)) {
Log.v("InstantRun",
"Received connection from IDE: spawning connection thread");
}
Server.SocketServerReplyThread socketServerReplyThread = new Server.SocketServerReplyThread(
socket);
socketServerReplyThread.run();
if (Server.sWrongTokenCount > 50) {
if (Log.isLoggable("InstantRun", 2)) {
Log.v("InstantRun",
"Stopping server: too many wrong token connections");
}
Server.this.mServerSocket.close();
break;
}
}
} catch (Throwable e) {
if (Log.isLoggable("InstantRun", 2)) {
Log.v("InstantRun",
"Fatal error accepting connection on local socket",
e);
}
}
}
public SocketLike(LocalSocket socket, LeakyBufferedInputStream leakyInput) {
OutputStream temp = null;
try {
temp = socket.getOutputStream();
} catch (IOException e) {
e.printStackTrace();
}
outputStream = temp;
mLeakyInput = leakyInput;
}
@Override
public final void onAccepted(LocalSocket socket) throws IOException {
try {
enforcePermission(mContext, socket);
onSecured(socket);
} catch (PeerAuthorizationException e) {
LogUtil.e("Unauthorized request: " + e.getMessage());
}
}
private void listenOnAddress(String address) throws IOException {
mServerSocket = bindToSocket(address);
LogUtil.i("Listening on @" + address);
while (!Thread.interrupted()) {
try {
// Use previously accepted socket the first time around, otherwise wait to
// accept another.
LocalSocket socket = mServerSocket.accept();
// Start worker thread
Thread t = new WorkerThread(socket, mSocketHandler);
t.setName(
WORKER_THREAD_NAME_PREFIX +
"-" + mFriendlyName +
"-" + mThreadId.incrementAndGet());
t.setDaemon(true);
t.start();
} catch (SocketException se) {
// ignore exception if interrupting the thread
if (Thread.interrupted()) {
break;
}
LogUtil.w(se, "I/O error");
} catch (InterruptedIOException ex) {
break;
} catch (IOException e) {
LogUtil.w(e, "I/O error initialising connection thread");
break;
}
}
LogUtil.i("Server shutdown on @" + address);
}
@Override
public final void onAccepted(LocalSocket socket) throws IOException {
try {
enforcePermission(mContext, socket);
onSecured(socket);
} catch (PeerAuthorizationException e) {
LogUtil.e("Unauthorized request: " + e.getMessage());
}
}
private void listenOnAddress(String address) throws IOException {
mServerSocket = bindToSocket(address);
LogUtil.i("Listening on @" + address);
while (!Thread.interrupted()) {
try {
// Use previously accepted socket the first time around, otherwise wait to
// accept another.
LocalSocket socket = mServerSocket.accept();
// Start worker thread
Thread t = new WorkerThread(socket, mSocketHandler);
t.setName(
WORKER_THREAD_NAME_PREFIX +
"-" + mFriendlyName +
"-" + mThreadId.incrementAndGet());
t.setDaemon(true);
t.start();
} catch (SocketException se) {
// ignore exception if interrupting the thread
if (Thread.interrupted()) {
break;
}
LogUtil.w(se, "I/O error");
} catch (InterruptedIOException ex) {
break;
} catch (IOException e) {
LogUtil.w(e, "I/O error initialising connection thread");
break;
}
}
LogUtil.i("Server shutdown on @" + address);
}
@Override
public final void onAccepted(LocalSocket socket) throws IOException {
try {
enforcePermission(mContext, socket);
onSecured(socket);
} catch (PeerAuthorizationException e) {
LogUtil.e("Unauthorized request: " + e.getMessage());
}
}