HarmonyOS Sample Network Management

[[425392]]

For more information, please visit:

Hongmeng Technology Community jointly built by 51CTO and Huawei

https://harmonyos..com

1. Introduction

This example demonstrates how to use the network management module related interfaces and demonstrates the following functions:

Function 1: Use the default network, open a connection, and send an HTTP request.

Function 2: Statistics the upstream/downstream traffic of the specified UID.

Function 3: Use Socket to realize communication between different devices.

This function requires that WIFI is turned on and the communicating devices are connected to the same WIFI to form a local area network.

In terms of operation, start the server first, then start the client, and then send a message from the client to see if the server receives the message.

Function 4: Use HTTP cache to create a cache for the next request, reducing data traffic and loading time.

Note that the following permissions are required:

ohos.permission.GET_NETWORK_INFO Get network connection information.

ohos.permission.SET_NETWORK_INFO Modify the network connection status.

ohos.permission.INTERNET Allows an application to open network sockets and make network connections.

For details, see the official document Network Management Development Overview

2. Build the environment

Install DevEco Studio. For details, see DevEco Studio Download.

Set up the DevEco Studio development environment. The DevEco Studio development environment needs to rely on the network environment. You need to connect to the network to ensure the normal use of the tool. You can configure the development environment according to the following two situations:

If you can access the Internet directly, you only need to download the HarmonyOS SDK.

If the network cannot directly access the Internet and needs to access it through a proxy server, please refer to Configuring the Development Environment.

After downloading the source code, use DevEco Studio to open the project and run the simulator.

To run on a real device, you need to change the buddleName in config.json to your own. If you have not done so, please configure it on AppGallery Connect. For details, see Debugging with the Simulator.

3. Code structure

3.1 Code Structure

3.2 Related Documents

Core Classes:

HttpURLConnection.java //URLConnection that supports HTTP specific functions

URLConnection.java //URL connection

URL.java //Pointer to a "resource" on the World Wide Web

NetStatusCallback.java //Callback class for network status, triggers onAvailable function when available network appears

DataFlowStatistics.java //This class provides an interface for querying the overall flow statistics and flow statistics of a specified cellular network, application, and network card.

DatagramSocket.java //This class represents a socket used to send and receive datagram packets.

DatagramPacket.java //Datagram packet

WifiDevice.java //This class provides Wi-Fi management interface

NetManager.java //Provides interfaces to manage and use data networks.

NetHandle.java // Data network

InetAddress.java //Network IP address

HttpResponseCache.java //This class caches HTTP and HTTPS responses for reuse

Custom class:

ThreadPoolUtil.java //Thread pool tool class

MainAbilitySlice.java //Main page

NetRequestSlice.java //Network request & traffic statistics function page

SocketClientSlice.java //Socket client

SocketServerSlice.java //Socket server

HttpCacheSlice.java //HTTP cache function page

Page Layout:

http_cache_slice.xml //HTTP cache sample page

net_request.slice.xml //HTTP request page

socket_client_slice.xml //Socket communication client page

socket_server_slice.xml //Socket communication server page

main_ability_slice.xml //Main page

4. Example explanation

4.1. Interface layout

4.2. Background code

4.2.1 NetRequestSlice.java Network request & traffic statistics function

a. Initialize the network management object NetManager

 // Initialize the network management object
 netManager = NetManager.getInstance( null );

b. Get a new thread from the thread pool to process the connection request

The ohos.permission.GET_NETWORK_INFO permission is required to obtain the default data network.

 //Use the thread pool to get a new thread to process
 ThreadPoolUtil.submit(() -> {
    HiLog.debug(LABEL_LOG, "%{public}s" , "ThreadPoolUtil submit" );
 //Get the default data network. When both wifi and traffic are turned off, netId==0, otherwise netId=390/391. You must have the ohos.permission.GET_NETWORK_INFO permission
    NetHandle netHandle = netManager.getDefaultNet();
 //Receive callback for status changes of the default data network
    netManager.addDefaultNetStatusCallback(callback); 
 
    //netManager.setAppNet(netHandle); 
 
 // A URLConnection that supports HTTP specific features.
    HttpURLConnection connection = null ;
 //Output stream
    try (ByteArrayOutputStream outputStream = new ByteArrayOutputStream()) {
 //Requested URL
        String urlString = inputText.getText(); 
 
        URL url = new URL(urlString);
 //Use netHandle to open the URL connection without using a proxy
        URLConnection urlConnection = netHandle.openConnection(url, java.net.Proxy.NO_PROXY);
        HiLog.debug(LABEL_LOG, "%{public}s" , "netHandle openConnection" );
 //Strong conversion type
        if (urlConnection instanceof HttpURLConnection) {
 connection = (HttpURLConnection) urlConnection;
 }
 // Request type
 connection .setRequestMethod( "GET" );
        //connect
 connection.connect ( ) ;
 //Traffic statistics
        trafficDataStatistics( false ); 
 
        try (InputStream inputStream = urlConnection.getInputStream()) {
            byte[] cache = new byte[2 * 1024];
 int len ​​= inputStream.read ( cache);
            while (len != -1) {
 //
                outputStream.write(cache, 0, len);
                len = inputStream.read (cache);
 }
        } catch (IOException e) {
            HiLog.error(LABEL_LOG, "%{public}s" , "netRequest inner IOException" );
 }
 //Return result
        String result = new String(outputStream.toByteArray()); 
 
 //UI display
        getUITaskDispatcher().asyncDispatch(() -> outText.setText(result));
 //Statistics completed
        trafficDataStatistics( true ); 
 
 } catch (IOException e) {
        HiLog.error(LABEL_LOG, "%{public}s" , "netRequest IOException" );
 }
 });

c. Perform data traffic statistics according to application ID

Get it once before sending the request and once after the request is completed.

There is a typo in the gitee code. tx represents uplink traffic and rx represents downlink traffic. For details, see the official document explaining traffic statistics.

 /**
 * Perform data traffic statistics based on application ID
 *
 * @param isStart
 */
  private void trafficDataStatistics(boolean isStart) {
 int uid = 0;
 try {
 //Get the application UID based on the given package name and user ID.
          uid = getBundleManager().getUidByBundleName(getBundleName(), 0);
      } catch (RemoteException e) {
          HiLog.error(LABEL_LOG, "%{public}s" , "trafficDataStatistics RemoteException" );
 }
 if (isStart) {
 //Get the downstream traffic of the specified UID.
          rx = DataFlowStatistics.getUidRxBytes(uid);
 //Get the upstream traffic of the specified UID.
          tx = DataFlowStatistics.getUidTxBytes(uid);
 } else {
          rx = DataFlowStatistics.getUidRxBytes(uid) - rx;
          tx = DataFlowStatistics.getUidTxBytes(uid) - tx; 
 
 //Set UI display
          getUITaskDispatcher().asyncDispatch(() -> statisticsText.setText(
 "TrafficDataStatistics:" + System.lineSeparator()
                          + "Receive traffic:" + rx + System.lineSeparator()
                          + "Sent traffic:" + tx));
 }
 }
 }

4.2.2 SocketClientSlice.java/SocketServerSlice.java Socket Client/Server

To realize Socket communication, a client and a server are required. The server listens to the specified port on the specified network card, and the client sends data to the specified IP and port to realize communication.

a. The Socket server starts listening and waits for receiving data

 //Listening port
 private static final int PORT = 8888; 
 
 /**
 * Start socket service monitoring
 *
 * @param component
 */
 private void startServer(Component component) {
    HiLog.debug(LABEL_LOG, "startServer" ); 
     
 //Thread pool gets new thread processing
    ThreadPoolUtil.submit(() -> {
 //Start listening on the specified port
        try (DatagramSocket socket = new DatagramSocket(PORT)) {
 //Datagram packet
            DatagramPacket packet = new DatagramPacket(new byte[255], 255);
 //Infinite loop receiving data
 while ( true ) {
 //Receive data
                socket.receive(packet); 
                 
 // Synchronize the received data to be displayed through a dedicated thread
                getUITaskDispatcher().syncDispatch(() -> outText.setText(
 "Receive a message from :" + packet.getAddress().getHostAddress()
                                + System.lineSeparator() + " on port " + packet.getPort()
                                + System.lineSeparator() + "message:" + new String(
                                packet.getData()). substring (0, packet.getLength())
 ));
                packet.setLength(255); 
 
 // Delay to allow time for data processing
                Thread.sleep(1000);
 }
        } catch (IOException | InterruptedException e) {
            e.printStackTrace();
            HiLog.error(LABEL_LOG, "%{public}s" , "StartServer IOException | InterruptedException" + e);
 }
 });
 } 
 
 
 /**
 * Get the server IP address and display it to the client to send a message
 *
 * @return  
 */
 private String getLocationIpAddress() {
    HiLog.debug(LABEL_LOG, "getLocationIpAddress" );
 // Provides interfaces to manage Wi-Fi.
    WifiDevice wifiDevice = WifiDevice.getInstance(this);
    HiLog.debug(LABEL_LOG, "wifiDevice:" + wifiDevice);
 //WifiLinkedInfo provides information about Wi-Fi connections.
    Optional<WifiLinkedInfo> linkedInfo = wifiDevice.getLinkedInfo();
    HiLog.debug(LABEL_LOG, "linkedInfo：" + linkedInfo);
 //Get IP address
 int ip = linkedInfo.get().getIpAddress();
    HiLog.debug(LABEL_LOG, "ip：" + ip);
 return (ip & 0xFF) + "." + ((ip >> 8) & 0xFF) + "." + ((ip >> 16) & 0xFF) + "." + (ip >> 24 & 0xFF);
 }

b.Socket client sends data and waits for receiving data

Initialize NetManager object->new a DatagramSocket->get the current data network NetHandle->get the server IP address object InetAddress

->Bind DatagramSocket to NetHandle ->Create a DatagramPacket ->Send data

 //Communication port
 private static final int PORT = 8888; 
 
 
 /**
 * Send network request
 * @param component
 */
 private void netRequest(Component component) {
    HiLog.debug(LABEL_LOG, "netRequest" );
 //Start a new thread
    ThreadPoolUtil.submit(() -> {
 // Initialize the network management object
        NetManager netManager = NetManager.getInstance( null ); 
 
 // Check if the default data network is activated.
        if (!netManager.hasDefaultNet()) {
 return ;
 }
 //new socket
        try (DatagramSocket socket = new DatagramSocket()) {
 //Get the current data network
            NetHandle netHandle = netManager.getDefaultNet(); 
 
 //Get the server's IP address
            InetAddress address = netHandle.getByName(inputText.getText());
 //Bind the socket to the current network
            netHandle.bindSocket(socket);
            byte[] buffer = "I'm from Client" .getBytes();
 //Data packet
            DatagramPacket request = new DatagramPacket(buffer, buffer.length, address, PORT);
 //Send data
            socket.send(request);
            HiLog.debug(LABEL_LOG, "send socket" );
        } catch (IOException e) {
            e.printStackTrace();
            HiLog.error(LABEL_LOG, "%{public}s" , "netRequest IOException" +e);
 }
 });
 }

4.2.3 HttpCacheSlice.java HTTP caching function

When an application repeatedly opens the same web page, it can prioritize reading content from the cache file, thereby reducing data traffic, lowering device power consumption, and improving application performance.

Q: How to set the priority to read content from the cache file?

A: No additional settings are required, it is automatic~~

When setting up a cache, you need to consider the cache location and cache size.

a. Initialize cache install

 /**
 * Enable caching
 * Automatically cache data after turning it on, no manual processing required
 */
 private void initCache(Component component) {
 //Default cache directory
    File httpCacheDir = new File(this.getCacheDir(), "http" );
 // Cache size
    long httpCacheSize = 10 * 1024 * 1024;
 try {
 //Configure the cache directory and maximum cache space
        HttpResponseCache.install(httpCacheDir, httpCacheSize);
        HiLog.debug(LABEL_LOG, "%{public}s" , "initCache,cache installed[" + httpCacheDir + "]" );
 } catch (IOException e) {
        HiLog.error(LABEL_LOG, "%{public}s" , "initCache IOException" );
 }
 }

b. Save the cache and write the cache to the file system flush

 /**
 * Write the cache to the file system to prevent cache loss
 */
 private void flushCache(Component component) {
    HiLog.debug(LABEL_LOG, "%{public}s" , "flushCache" );
 try {
 //Get the cache object
        HttpResponseCache cache = HttpResponseCache.getInstalled();
        HiLog.debug(LABEL_LOG, "%{public}s" , "cache:" +cache);
 if (cache != null ) {
 try {
 //Write the cache to the file system. If cache is closed, an error will be reported. //java.lang.IllegalStateException: cache is closed
                cache.flush();
                getUITaskDispatcher().syncDispatch(() -> {
 //Image loading time, test the difference between caching and not caching
                    duration.setText( "cache flush success" );
 });
                HiLog.debug(LABEL_LOG, "%{public}s" , "cache flush" );
            } catch (IOException e) {
                HiLog.error(LABEL_LOG, "%{public}s" , "onStop IOException" );
 }
 }
    } catch (IllegalStateException e) {
 e.printStackTrace();
 }
 }

c. Disable the cache and delete the data in it delete

 /**
 * Disable the cache and delete the data in it
 */
 private void deleteCache(Component component) {
    HiLog.debug(LABEL_LOG, "%{public}s" , "deleteCache" );
 //Get the cache object
    HttpResponseCache cache = HttpResponseCache.getInstalled();
    HiLog.debug(LABEL_LOG, "%{public}s" , "cache:" +cache);
 if (cache != null ) {
 try {
 // Disable the cache and delete the data in it.
 cache.delete ();
            image.setPixelMap( null );
            HiLog.debug(LABEL_LOG, "%{public}s" , "cache delete" );
        } catch (IOException e) {
            HiLog.error(LABEL_LOG, "%{public}s" , "onStop IOException" );
 } 
 
 }
 } 
 
 /**
 * Test request
 *
 * @param component
 */
 private void startRequest(Component component) {
    HiLog.debug(LABEL_LOG, "%{public}s" , "startRequest" );
    ThreadPoolUtil.submit(() -> {
 try {
            long startTime=System.currentTimeMillis();
            HiLog.debug(LABEL_LOG, "%{public}s" , "startTime:" +startTime);
 //Request URL
            URL url = new URL(inputText.getText());
            URLConnection urlConnection = url.openConnection();
            HiLog.debug(LABEL_LOG, "%{public}s" , "openConnection" );
 // Determine the connection type
            if (urlConnection instanceof HttpURLConnection) {
                HiLog.debug(LABEL_LOG, "%{public}s" , "urlConnection" );
                HttpURLConnection connection = (HttpURLConnection) urlConnection;
                HiLog.debug(LABEL_LOG, "%{public}s" , "connect:" + connection );
                //connect
 connection.connect ( ) ;
                HiLog.debug(LABEL_LOG, "%{public}s" , "connected" );
 //Connection result
                if ( connection .getResponseCode() == HttpURLConnection.HTTP_OK) {
                    HiLog.debug(LABEL_LOG, "%{public}s" , "HTTP_OK" );
 //Describes image data source options, including for example the image format represented as image/png.
                    ImageSource.SourceOptions srcOpts = new ImageSource.SourceOptions();
                    ImageSource imageSource = ImageSource. create ( connection .getInputStream(), srcOpts);
 // Provide the image as a matrix of pixels.
                    PixelMap pixelMap = imageSource.createPixelmap( null );
                    HiLog.debug(LABEL_LOG, "%{public}s" , "pixelMap:" +pixelMap);
 //Specialized thread synchronization settings picture display
                    getUITaskDispatcher().syncDispatch(() -> {
                        image.setPixelMap(pixelMap);
 //Image loading time, test the difference between caching and not caching
                        duration.setText(String.valueOf(System.currentTimeMillis()-startTime)+ " ms" );
 });
                    HiLog.debug(LABEL_LOG, "%{public}s" , "setPixelMap" );
                    HiLog.debug(LABEL_LOG, "%{public}s" , "endTime:" + (System.currentTimeMillis()-startTime));
 }
                HiLog.debug(LABEL_LOG, "%{public}s" , "finish" );
 //Close the connection
 connection .disconnect();
 }
        } catch (Exception e) {
            HiLog.error(LABEL_LOG, "%{public}s" , "initCache Exception" +e);
            getUITaskDispatcher().syncDispatch(() -> {
 //Image loading time, test the difference between caching and not caching
                duration.setText( "cache is closed, please open cache" );
 });
 }
 });
 }

5. Summary

(1) Two ways to open a network connection

 URLConnection urlConnection = url.openConnection();

 //Use netHandle to open the URL connection without using a proxy
 URLConnection urlConnection = netHandle.openConnection(url, java.net.Proxy.NO_PROXY);

(2) When caching is not enabled, the time to send a request is between 400-2000ms. When caching is enabled, you need to click twice to send a request, and the time remains at around 90-200ms.

(3) After disabling and clearing the cache delete/close, no request can be sent until the cache is enabled again. The official documentation for this operation states "Close the cache at the end."

6. Complete code

Download attachments directly

For more information, please visit:

Hongmeng Technology Community jointly built by 51CTO and Huawei

https://harmonyos..com