Shulou(Shulou.com)06/02 Report--

This article will explain in detail how to use HMS Nearby Service to add short-range data transmission function to your App, the content of the article is of high quality, so the editor shares it for you to do a reference. I hope you will have a certain understanding of the relevant knowledge after reading this article.

  : when you send mobile phone information to your friends, the progress bar does not move for a long time; when you want to send large files to colleagues, only one file uses up all your traffic; when you want to play games with your friends on a plane, you have no choice but to give up because there is no Internet.   

It seems that we often encounter this awkward situation in our life, and the function of close data transmission is a pain point for users. Now, you only need to access Huawei's short-range communication service, and you can easily transfer data between devices through Nearby Connection. The transmission type supports short text, streaming data and file data, which can help app realize local multiplayer games, real-time collaboration, multi-screen games and offline file transfer. The following figure is a functional demonstration:

   if you are interested in how to implement it, you can download the source code on Github:

   https://github.com/HMS-Core/hms-nearby-demo/tree/master/NearbyConnection

   first needs to understand the Nearby Connection development process.

1. Business proc

The overall process of    can be divided into four stages.

   broadcast scanning phase: the broadcaster initiates the broadcast, and the discoverer initiates scanning to discover the broadcaster.

The broadcaster calls startBroadcasting () to start the broadcast.

The discoverer calls startScan () to start the scan to find nearby devices.

The scan result is notified by the onFound () method.

   connection establishment phase: the discoverer initiates the connection and initiates the symmetrical authentication process, and both sides accept or reject the connection request independently.

The discoverer calls requestConnect () to initiate a connection request to the broadcaster.

After the connection is started by onEstablish () on both sides, you can call acceptConnect () to accept the connection or rejectConnect () to reject the connection.

The result of the connection is notified by onResult () at both ends. A connection can be established only if both ends accept the connection.

   data transmission phase: after the connection is established, the two sides exchange data.

After the connection is established, both sides can call sendData () to send data to the peer.

One end of the receiving data is notified by onReceived () that the data is received; on both sides, the current transmission status is notified by onTransferUpdate ().

   disconnection phase: either end of both ends initiates a disconnection to notify the opposite end of the disconnection.

One end of the active disconnection calls disconnect () to disconnect, and the other end is told by onDisconnected () to disconnect.

two。 Development step 2.1 Development preparation

   if you have no previous experience in integrating Huawei mobile services, you need to configure AppGallery Connect, activate near-distance communication services and integrate HMS SDK. Please refer to the official documentation for the relevant steps.

2.2 declare system permissions

The    Nearby Connection development scenario requires the use of Nearby Discovery API and Nearby Transfer API, and your application must declare the appropriate permissions according to the policy used. For example, if you use POLICY_STAR policy to develop file transfer applications, you need to add specific permissions to AndroidManifest.xml:

   because ACCESS_FINE_LOCATION,WRITE_EXTERNAL_STORAGE and READ_EXTERNAL_STORAGE are dangerous system permissions, these permissions must be applied for dynamically. If the permissions are insufficient, the near distance Communication Service (Nearby Service) will refuse to allow the application to turn on broadcasting or discovery.

2.3 Select Strategy

   Nearby Discovery supports three different connection strategies: POLICY_MESH,POLICY_STAR and POLICY_P2P. The strategy can be selected according to the application scenario.

The example code for    policy to select and create a BroadcastOption object is as follows:

Policy policy = Policy.POLICY_STAR; BroadcastOption broadcastOption = new BroadcastOption.Builder (). SetPolicy (policy). Build (); 2.4 broadcast and scan

Once    grants the permissions required by the application and selects a policy for the application, it can start broadcasting and scanning to discover nearby devices.

2.4.1 start the broadcast

The    broadcaster calls startBroadcasting () to start the broadcast with the selected policy and serviceId as parameters. The application where serviceId should be uniquely identified. It is recommended that you use the package name of the application as the serviceId (for example: com.huawei.example.myapp). The sample code is as follows:

Private void doStartBroadcasting () {Policy policy = Policy.POLICY_STAR; BroadcastOption broadcastOption = new BroadcastOption.Builder () .setPolicy (policy) .build () Nearby.getDiscoveryEngine (getApplicationContext ()) .startBroadcasting (name, serviceId, connectCallback, broadcastOption) .addOnSuccessListener (new OnSuccessListener () {@ Override public void onSuccess (Void aVoid) {/ * We are broadcasting. * /}) .addOnFailureListener (new OnFailureListener () {@ Override public void onFailure (Exception e) {/ * Fail to start broadcasting. * /}});}

The    parameter connectCallback is an instance of the connection listening callback class, which is used to notify connection status information. For more information about the ConnectCallback class and sample code, see the confirm connections section.

2.4.2 start scan

The    discoverer calls startScan () to start the scan to discover nearby devices with the selected policy and serviceId as parameters. The sample code is as follows:

Private void doStartScan () {Policy policy = Policy.POLICY_STAR; ScanOption scanOption = new ScanOption.Builder () .setPolicy (policy) .build () Nearby.getDiscoveryEngine (getApplicationContext ()) .startScan (serviceId, scanEndpointCallback, scanOption) .addOnSuccessListener (new OnSuccessListener () {@ Override public void onSuccess (Void aVoid) {/ * Start scan success. * /}) .addOnFailureListener (new OnFailureListener () {@ Override public void onFailure (Exception e) {/ * Fail to start scan. * /}});}

The    parameter scanEndpointCallback is an instance of the scan listening callback class, which notifies the discoverer of the scan result and discovers the device or the device has been found missing.

Private ScanEndpointCallback scanEndpointCallback = new ScanEndpointCallback () {@ Override public void onFound (String endpointId, ScanEndpointInfo discoveryEndpointInfo) {mEndpointId = endpointId; mDiscoveryEngine.requestConnect (myNameStr, mEndpointId, mConnCb) } @ Override public void onLost (String endpointId) {Log.d (TAG, "Nearby Connection Demo app: Lost endpoint:" + endpointId);}}; 2.4.3 stop broadcasting

   calls stopBroadcasting () when it needs to stop broadcasting. After the broadcast is stopped, the broadcaster cannot receive connection requests from the discoverer.

2.4.4 stop scanning

   calls stopScan () when it needs to stop scanning. After the scan is stopped, the discoverer can still request a connection from the discovered device. A common practice is to call stopScan () to stop scanning as soon as you find a device that needs to be connected.

2.5 establish a connection 2.5.1 request a connection

   when a nearby device is discovered, the discoverer can call requestConnect () to initiate the connection. The sample code is as follows:

Private void doStartConnect (String name, String endpointId) throws RemoteException {Nearby.getDiscoveryEngine (getApplicationContext ()) .requestConnect (name, endpointId, connectCallback) .addOnSuccessListener (new OnSuccessListener () {@ Override public void onSuccess (Void aVoid) {/ * Request success. * /}) .addOnFailureListener (new OnFailureListener () {@ Override public void onFailure (Exception e) {/ * Fail to request connect. * /}});}

  , of course, can show users a list of devices found and allow them to choose which devices to connect to, as needed.

2.5.2 confirm connection

After the    discoverer initiates the connection, it notifies both parties of the connection establishment event by calling back the onEstablish () method of connectCallback. Both parties must accept the connection by calling acceptConnect () or reject the connection by calling rejectConnect (). The connection is established successfully only if both parties accept the connection. If one or both parties choose to refuse, the connection fails. Either way, the result of the connection is notified by the onResult () method. The sample code is as follows:

Private final ConnectCallback connectCallback = new ConnectCallback () {@ Override public void onEstablish (String endpointId, ConnectInfo connectInfo) {/ * Accept the connection request without notifying user. * / Nearby.getDiscoveryEngine (getApplicationContext ()) .artictConnect (endpointId, dataCallback);} @ Override public void onResult (String endpointId, ConnectResult result) {switch (result.getStatus (). GetStatusCode ()) {case StatusCode.STATUS_SUCCESS: / * The connection was established successfully, we can exchange data. * / break; case StatusCode.STATUS_CONNECT_REJECTED: / * The Connection was rejected. * / break; default: / * other unknown status code. * /} @ Override public void onDisconnected (String endpointId) {/ * The connection was disconneted * /}}

   this example shows a confirmation connection in which both parties automatically accept the connection. Other ways to confirm the connection can be used as needed.

2.5.3 verify the connection

   applications can provide a way for users to confirm that they are connected to a specified device, for example, by verifying token (token can be a short random string or number). Typically this involves displaying the token on both devices and asking the user to enter or confirm manually, similar to the Bluetooth pairing dialog box.

   below demonstrates a way to verify the connection by confirming the pairing code through the pop-up window. The sample code is as follows:

@ Override public void onEstablish (String endpointId, ConnectInfo connectInfo) {AlertDialog.Builder builder = new AlertDialog.Builder (getApplicationContext ()) Builder.setTitle (connectInfo.getEndpointName () + "request connection") .setMessage ("Please confirm the match code is:" + connectInfo.getAuthCode ()) .setPositiveButton ("Accept", (DialogInterface dialog, int which)-> / * Accept the connection. * / Nearby.getDiscoveryEngine (getApplicationContext ()) .butttConnect (endpointId, dataCallback) .setNegativeButton ("Reject", (DialogInterface dialog, int which)-> / * Reject the connection. * / Nearby.getDiscoveryEngine (getApplicationContext ()) .RejectConnect (endpointId) .setIcon (android.R.drawable.ic_dialog_alert); AlertDialog alert = builder.create (); alert.show ();} 2.6 transfer data

After a connection is established between    devices, you can use that connection to transfer Data objects. The types of Data objects include byte sequences, files, and streams. Send the data by calling the sendData () method and receive the data through the onReceived () method of the DataCallback class instance.

2.6.1 data type

BYTES

Create a Data object of type Data.Type.BYTES by calling Data.fromBytes ().

Send data of type BYTES. The sample code is as follows:

Data bytesData = Data.fromBytes (new byte [] {0xA, 0xA, 0xA, 0xA, 0xA}); Nearby.getTransferEngine (getApplicationContext ()) .sendData (toEndpointId, bytesData)

   Note: the length size of BYTES type data cannot exceed 32KB.

   receives data of type BYTES. The sample code is as follows:

Static class BytesDataReceiver extends DataCallback {@ Override public void onReceived (String endpointId, Data data) {/ * BYTES data is sent as a single block, so we can get complete data. * / if (data.getType () = = Data.Type.BYTES) {byte [] receivedBytes = data.asBytes ();} @ Override public void onTransferUpdate (String endpointId, TransferStateUpdate update) {/ * We will receive TRANSFER_STATE_SUCCESS update after onReceived () called. * /}}

   Note: BYTES is different from FILE and STREAM types, BYTES is sent as a single data block, so the receiver does not have to wait for the status of BYTES type to be updated to TRANSFER_STATE_SUCCESS, when onReceived () is called, you can call data.asBytes () to get all the data.

FILE

Create a Data object of type Data.Type.FILE by calling Data.fromFile ().

The sample code for sending FILE type data is as follows:

File fileToSend = new File (getApplicationContext (). GetFilesDir (), "fileSample.txt"); try {Data fileData = Data.fromFile (fileToSend); Nearby.getTransferEngine (getApplicationContext ()) .sendData (endpointList, fileData);} catch (FileNotFoundException e) {/ * Exception handle. * /}

A more efficient approach to    is to create FILE types using ParcelFileDescriptor, which minimizes file replication. The sample code is as follows:

ParcelFileDescriptor pfd = getContentResolver () .openFileDescriptor (uri, "r"); Data fileData = Data.fromFile (pfd)

After the    receiving device receives the file, the file is saved in the Download directory and will be named after the string converted by fileData.getId (). After the transfer is complete, you can get the FILE object. The sample code is as follows:

/ * We can get the received file in the Download folder. * / File payloadFile = fileData.asFile () .asJavaFile ()

STREAM

   creates a Data object of type Data.Type.STREAM by calling Data.fromStream (). The sample code for sending a stream is as follows:

URL url = new URL ("https://developers.huawei.com"); Data streamData = Data.fromStream (url.openStream ()); Nearby.getTransferEngine (getApplicationContext ()) .sendData (toEndpointId, streamData))

On the    receiver, when the onTransferUpdate () callback is successful, you can call streamData.asStream (). AsInputStream () or streamData.asStream (). AsParcelFileDescriptor () to get the stream object. The sample code is as follows:

Static class StreamDataReceiver extends DataCallback {private final HashMap incomingData = new HashMap (); @ Override public void onTransferUpdate (String endpointId, TransferStateUpdate update) {if (update.getStatus () = = TransferStateUpdate.Status.TRANSFER_STATE_SUCCESS) {Data data = incomingData.get (update.getDataId ()); InputStream inputStream = data.asStream (). AsInputStream (); / * Further processing... * /} @ Override public void onReceived (String endpointId, Data data) {incomingData.put (data.getId (), data);} 2.6.2 Progress Update

The    DataCallBack callback class onTransferUpdate () method provides progress updates for sending or receiving data, based on which the transmission progress can be displayed to the user, for example, a progress bar.

2.6.3 cancel transmission

If    needs to cancel the transmission during receiving or sending, call the TransferEngine class instance method cancelDataTransfer ().

2.7 disconnect

If    needs to disconnect from the peer, call the DiscoveryEngine class instance method disconnect (). Once this interface is called, you cannot send and receive data from this endpoint.

On how to use HMS Nearby Service to add short-range data transmission function to their App to share here, I hope the above content can be of some help to you, can learn more knowledge. If you think the article is good, you can share it for more people to see.

Welcome to subscribe "Shulou Technology Information " to get latest news, interesting things and hot topics in the IT industry, and controls the hottest and latest Internet news, technology news and IT industry trends.