I saw an article before introducing five communication methods between apps, including URL Scheme, Keychain, UIPastedboard, UIDocumentInteractionController and local communication using sockets. The first 4 types have been used, and they are relatively simple, with a few lines of code. The last one has never been used before (forgive me, I am still a novice), so I tried to write it down today, and I will share it with you here.
OK, let's not talk much, start:
First of all, let’s talk about its principle. It is actually very simple. An App binds and listens to TCP on the local port, and another App connects to the same port on the local port. This establishes a normal TCP connection and can transfer any data you want. Let’s start creating the server:
1. First use the socket() function to create a socket
/*
* socket returns an int value, -1 is creation failure
* The first parameter specifies the protocol family/domain, usually AF_INET(IPV4), AF_INET6(IPV6), AF_LOCAL
* The second parameter specifies a socket type: SOCK_STREAM, SOCK_DGRAM, SOCK_SEQPACKET, etc.
* The third parameter specifies the corresponding transmission protocol, such as TCP/UDP, etc., which is generally set to 0 to use this default value.
*/
int sock = socket(AF_INET, SOCK_STREAM, 0);
if(sock == -1){
close(sock);
NSLog(@"socket error : %d",sock);<br> return;
}
/*
* socket returns an int value, -1 is creation failure
* The first parameter specifies the protocol family/domain, usually AF_INET(IPV4), AF_INET6(IPV6), AF_LOCAL
* The second parameter specifies a socket type: SOCK_STREAM, SOCK_DGRAM, SOCK_SEQPACKET, etc.
* The third parameter specifies the corresponding transmission protocol, such as TCP/UDP, etc., which is generally set to 0 to use this default value.
*/
int sock = socket(AF_INET, SOCK_STREAM, 0);
if(sock == -1){
close(sock);
NSLog(@"socket error : %d",sock);<br> return;
}
2. Bind the local address and port number
// Address structure data, record ip and port numberstruct sockaddr_in sockAddr;
// Declare the protocol usedsockAddr.sin_family = AF_INET;
// Get the ip of the machine and convert it to char typeconst char *ip = [[self getIPAddress] cStringUsingEncoding:NSASCIIStringEncoding];
// Assign ip to the structure, the inet_addr() function converts a dotted decimal IP into a long integer numbersockAddr.sin_addr.s_addr = inet_addr(ip);
// Set the port number, htons() is to convert integer variables from host byte order to network byte ordersockAddr.sin_port = htons(12345);
/*
* bind function is used to associate a socket with an address, return an int value, -1 is a failure
* The first parameter specifies the socket, which is the previous socket function call returns the nominal socket
* The second parameter is the specified address
* The third parameter is the size of the address data
*/
int bd = bind(sock,(struct sockaddr *) &sockAddr, sizeof(sockAddr));
if(bd == -1){
close(sock);
NSLog(@"bind error : %d",bd);
return;
}
3. Listen to the bound address
/*
* The listen function uses the actively connected socket interface to become the connected interface, so that it can accept requests from other processes, return an int value, and -1 is a failure
* The first parameter is the socket returned by the previous socket function
* The second parameter can be understood as the maximum limit of the connection
*/
int ls = listen(sock,20);
if(ls == -1){
close(sock);
NSLog(@"listen error : %d",ls);
return;
}
4. The following is waiting for the client's connection, using accept() (because the accept function will block the thread and will be stuck during the waiting process, so it is recommended to put it in the child thread)
// 1. Open a child thread
NSTread *recvThread = [[NSThread alloc] initwithTarget:self selector:@selector(recvData) object: nil];
[recvThread start];
- (void)recvData{
// 2. Wait for the client to connect
// Declare an address structure to later receive the address returned by the client struct sockaddr_in recvAddr;
// Address size socklen_t recv_size = sizeof(struct sockaddr_in);
/*
* The accept() function will return a new socket() after the connection is successful, which is used to send and receive data after and before the client.
* The first parameter is the socket listened to before, which was a local variable before, but now it needs to be changed to global
* The second parameter is a result parameter, which is used to receive a return value, which specifies the address of the client
* The third parameter is also a result parameter, which is used to receive the sales of the recvAddr structure and specify the number of bytes it occupies.
*/
= accept(,(struct sockaddr *) &recvAddr, &recv_size);
// 3. Coming here means that you have connected to a new client, and you can send and receive data below. The send() and recv() functions are mainly used. ssize_t bytesRecv = -1; // Return data byte size char recvData[128] = ""; // Return to the data cache area// If one end is disconnected, recv will return immediately, bytesrecv equals 0, and then the while loop will continue to execute, so it is judged that equals 0 and jumps out while(1){
bytesRecv = recv(,recvData,128,0); // recvData is the received data if(bytesRecv == 0){
break;
}
}
}
5. Send data
- (void)sendMessage{
char sendData[32] = "hello client";
ssize_t size_t = send(, sendData, strlen(sendData), 0);
}
The client side is mainly divided into: creating sockets, obtaining the server's host address based on the IP and port numbers, and then connecting. After the connection is successful, you can send and receive data to the server. Let's look at the code below.
1. Create sockets using socket functions like the server.
int sock = socket(AF_INET, SOCK_STREAM,0);
if(sock == -1){
NSLog(@"socket error : %d",sock);
return;
}
2. Get the host address
NSString *host = [self getIPAddress]; // Get the IP address of the machine// Returns the host structure pointer corresponding to the given host name and address information.struct hostent *remoteHostEnt = gethostbyname([host UTF8String]);
if(remoteHostEnt == NULL){
close(sock);
NSLog(@"Unable to resolve server hostname");
return;
}<br>// Configure the socket to connect to the host's IP address and port number, and use it for the connect() functionstruct in_addr *remoteInAddr = (struct in_addr *)remoteHost->h_addr_list[0];
struct sockaddr_in socktPram;
socketPram.sin_family = AF_INT;
socketPram.sin_addr = *remoteInAddr;
socketPram.sin_port = htons([port intValue]);
3. Use the connect() function to connect to the host
/*
* The connect function is usually used for client resume tcp connection, connecting to the host of the specified address, the function returns an int value, -1 is a failure
* The first parameter is the socket created by the socket function, which means that the socket is to be connected to the specified host.
* The second parameter is the host address and port number that the socket sock wants to connect to
* The third parameter is the host address size
*/
int con = connect(sock, (struct sockaddr *) &socketPram, sizeof(socketPram));
if(con == -1){
close(sock);
NSLog(@"Connection failed");
return;
}
NSLog("Connected successfully"); // Coming to this means the connection is successful;
4. After the connection is successful, you can send and receive data.
- (IBAction)senddata:(id)sender {
// Send data char sendData[32] = "hello service";
ssize_t size_t = send(, sendData, strlen(sendData), 0);
NSLog(@"%zd",size_t);
}
- (void)recvData{
// Accept data and place it in the child thread ssize_t bytesRecv = -1;
char recvData[32] = "";
while (1) {
bytesRecv = recv(, recvData, 32, 0);
NSLog(@"%zd %s",bytesRecv,recvData);
if (bytesRecv == 0) {
break;
}
}
}
OK, just use socket to communicate with two apps locally. The first time I wrote a blog post, I was to record my own experience, and I was to share with you. I hope you can point out any wrong things in the article. Finally, the address of the demo is attached, two projects. If you are interested, you can try it out:
The above is all the content of this article. I hope it will be helpful to everyone's study and I hope everyone will support me more.