From 6234775c1bc041453f1f09c8c44668228cd63894 Mon Sep 17 00:00:00 2001 From: Prerak Mann Date: Sat, 11 May 2019 23:03:23 +0530 Subject: [PATCH] working, reason unknown --- .../NearbyConnectionsPlugin.java | 51 +-- .../MainActivity.java | 358 +++++++++++++++++- 2 files changed, 379 insertions(+), 30 deletions(-) diff --git a/android/src/main/java/com/pkmnapps/nearby_connections/NearbyConnectionsPlugin.java b/android/src/main/java/com/pkmnapps/nearby_connections/NearbyConnectionsPlugin.java index 4546e62..a7b9921 100644 --- a/android/src/main/java/com/pkmnapps/nearby_connections/NearbyConnectionsPlugin.java +++ b/android/src/main/java/com/pkmnapps/nearby_connections/NearbyConnectionsPlugin.java @@ -33,6 +33,7 @@ import io.flutter.plugin.common.MethodChannel.Result; import io.flutter.plugin.common.PluginRegistry.Registrar; import android.util.Log; + /** * NearbyConnectionsPlugin */ @@ -86,22 +87,23 @@ public class NearbyConnectionsPlugin implements MethodCallHandler { int strategy = (int) call.argument("strategy"); assert userNickName != null; - Nearby.getConnectionsClient(activity).startAdvertising( - userNickName, - SERVICE_ID, - advertConnectionLifecycleCallback, - new AdvertisingOptions.Builder().setStrategy(getStrategy(strategy)).build()) + AdvertisingOptions advertisingOptions = new AdvertisingOptions.Builder() + .setStrategy(getStrategy(strategy)).build(); + + Nearby.getConnectionsClient(activity) + .startAdvertising( + userNickName, SERVICE_ID, advertConnectionLifecycleCallback, advertisingOptions) .addOnSuccessListener(new OnSuccessListener() { @Override public void onSuccess(Void aVoid) { - Log.d("NearbyCon java","started advertising"); result.success(true); + } }) .addOnFailureListener(new OnFailureListener() { @Override public void onFailure(@NonNull Exception e) { - result.error("Failure", e.getMessage(), null); + result.success(false); } }); break; @@ -111,32 +113,31 @@ public class NearbyConnectionsPlugin implements MethodCallHandler { int strategy = (int) call.argument("strategy"); assert userNickName != null; - Nearby.getConnectionsClient(activity).startDiscovery( - userNickName, - endpointDiscoveryCallback, - new DiscoveryOptions.Builder().setStrategy(getStrategy(strategy)).build()) + DiscoveryOptions discoveryOptions = + new DiscoveryOptions.Builder().setStrategy(getStrategy(strategy)).build(); + Nearby.getConnectionsClient(activity) + .startDiscovery(SERVICE_ID, endpointDiscoveryCallback, discoveryOptions) .addOnSuccessListener(new OnSuccessListener() { @Override public void onSuccess(Void aVoid) { - Log.d("NearbyCon java","started discovery"); result.success(true); } }) .addOnFailureListener(new OnFailureListener() { @Override public void onFailure(@NonNull Exception e) { - result.error("Failure", e.getMessage(), null); + result.success(false); } }); break; } case "stopAllEndpoints": - Log.d("NearbyCon java","stopAllEndpoints"); + Log.d("NearbyCon java", "stopAllEndpoints"); Nearby.getConnectionsClient(activity).stopAllEndpoints(); result.success(null); break; case "disconnectFromEndpoint": { - Log.d("NearbyCon java","disconnectFromEndpoint"); + Log.d("NearbyCon java", "disconnectFromEndpoint"); String endpointId = call.argument("endpointId"); assert endpointId != null; Nearby.getConnectionsClient(activity).disconnectFromEndpoint(endpointId); @@ -144,7 +145,7 @@ public class NearbyConnectionsPlugin implements MethodCallHandler { break; } case "requestConnection": { - Log.d("NearbyCon java","requestConnection"); + Log.d("NearbyCon java", "requestConnection"); String userNickName = (String) call.argument("userNickName"); String endpointId = (String) call.argument("endpointId"); @@ -206,7 +207,7 @@ public class NearbyConnectionsPlugin implements MethodCallHandler { }); break; } - case "sendPayload":{ + case "sendPayload": { //Nearby.getConnectionsClient(activity).sendPayload() break; } @@ -218,7 +219,7 @@ public class NearbyConnectionsPlugin implements MethodCallHandler { private final ConnectionLifecycleCallback advertConnectionLifecycleCallback = new ConnectionLifecycleCallback() { @Override public void onConnectionInitiated(@NonNull String endpointId, @NonNull ConnectionInfo connectionInfo) { - Log.d("NearbyCon java","ad.onConnectionInitiated"); + Log.d("NearbyCon java", "ad.onConnectionInitiated"); Map args = new HashMap<>(); args.put("endpointId", endpointId); args.put("endpointName", connectionInfo.getEndpointName()); @@ -229,7 +230,7 @@ public class NearbyConnectionsPlugin implements MethodCallHandler { @Override public void onConnectionResult(@NonNull String endpointId, @NonNull ConnectionResolution connectionResolution) { - Log.d("NearbyCon java","ad.onConnectionResult"); + Log.d("NearbyCon java", "ad.onConnectionResult"); Map args = new HashMap<>(); args.put("endpointId", endpointId); int statusCode = -1; @@ -255,7 +256,7 @@ public class NearbyConnectionsPlugin implements MethodCallHandler { @Override public void onDisconnected(@NonNull String endpointId) { - Log.d("NearbyCon java","ad.onDisconnected"); + Log.d("NearbyCon java", "ad.onDisconnected"); Map args = new HashMap<>(); args.put("endpointId", endpointId); channel.invokeMethod("ad.onDisconnected", args); @@ -265,7 +266,7 @@ public class NearbyConnectionsPlugin implements MethodCallHandler { private final ConnectionLifecycleCallback discoverConnectionLifecycleCallback = new ConnectionLifecycleCallback() { @Override public void onConnectionInitiated(@NonNull String endpointId, @NonNull ConnectionInfo connectionInfo) { - Log.d("NearbyCon java","dis.onConnectionInitiated"); + Log.d("NearbyCon java", "dis.onConnectionInitiated"); Map args = new HashMap<>(); args.put("endpointId", endpointId); args.put("endpointName", connectionInfo.getEndpointName()); @@ -276,7 +277,7 @@ public class NearbyConnectionsPlugin implements MethodCallHandler { @Override public void onConnectionResult(@NonNull String endpointId, @NonNull ConnectionResolution connectionResolution) { - Log.d("NearbyCon java","dis.onConnectionResult"); + Log.d("NearbyCon java", "dis.onConnectionResult"); Map args = new HashMap<>(); args.put("endpointId", endpointId); int statusCode = -1; @@ -302,7 +303,7 @@ public class NearbyConnectionsPlugin implements MethodCallHandler { @Override public void onDisconnected(@NonNull String endpointId) { - Log.d("NearbyCon java","dis.onDisconnected"); + Log.d("NearbyCon java", "dis.onDisconnected"); Map args = new HashMap<>(); args.put("endpointId", endpointId); channel.invokeMethod("dis.onDisconnected", args); @@ -324,7 +325,7 @@ public class NearbyConnectionsPlugin implements MethodCallHandler { private final EndpointDiscoveryCallback endpointDiscoveryCallback = new EndpointDiscoveryCallback() { @Override public void onEndpointFound(@NonNull String endpointId, @NonNull DiscoveredEndpointInfo discoveredEndpointInfo) { - Log.d("NearbyCon java","onEndpointFound"); + Log.d("NearbyCon java", "onEndpointFound"); Map args = new HashMap<>(); args.put("endpointId", endpointId); args.put("endpointName", discoveredEndpointInfo.getEndpointName()); @@ -334,7 +335,7 @@ public class NearbyConnectionsPlugin implements MethodCallHandler { @Override public void onEndpointLost(@NonNull String endpointId) { - Log.d("NearbyCon java","onEndpointLost"); + Log.d("NearbyCon java", "onEndpointLost"); Map args = new HashMap<>(); args.put("endpointId", endpointId); channel.invokeMethod("dis.onEndpointLost", args); diff --git a/example/android/app/src/main/java/com/pkmnapps/nearby_connections_example/MainActivity.java b/example/android/app/src/main/java/com/pkmnapps/nearby_connections_example/MainActivity.java index 5d1a45b..4b0929b 100644 --- a/example/android/app/src/main/java/com/pkmnapps/nearby_connections_example/MainActivity.java +++ b/example/android/app/src/main/java/com/pkmnapps/nearby_connections_example/MainActivity.java @@ -1,13 +1,361 @@ package com.pkmnapps.nearby_connections_example; +import android.Manifest; +import android.app.Activity; +import android.content.pm.PackageManager; import android.os.Bundle; +import android.support.annotation.NonNull; +import android.support.v4.app.ActivityCompat; +import android.support.v4.content.ContextCompat; +import android.util.Log; + +import com.google.android.gms.nearby.Nearby; +import com.google.android.gms.nearby.connection.AdvertisingOptions; +import com.google.android.gms.nearby.connection.ConnectionInfo; +import com.google.android.gms.nearby.connection.ConnectionLifecycleCallback; +import com.google.android.gms.nearby.connection.ConnectionResolution; +import com.google.android.gms.nearby.connection.ConnectionsStatusCodes; +import com.google.android.gms.nearby.connection.DiscoveredEndpointInfo; +import com.google.android.gms.nearby.connection.DiscoveryOptions; +import com.google.android.gms.nearby.connection.EndpointDiscoveryCallback; +import com.google.android.gms.nearby.connection.Payload; +import com.google.android.gms.nearby.connection.PayloadCallback; +import com.google.android.gms.nearby.connection.PayloadTransferUpdate; +import com.google.android.gms.nearby.connection.Strategy; +import com.google.android.gms.tasks.OnFailureListener; +import com.google.android.gms.tasks.OnSuccessListener; + +import java.util.HashMap; +import java.util.Map; + import io.flutter.app.FlutterActivity; +import io.flutter.plugin.common.MethodCall; +import io.flutter.plugin.common.MethodChannel; +import io.flutter.plugin.common.PluginRegistry; import io.flutter.plugins.GeneratedPluginRegistrant; public class MainActivity extends FlutterActivity { - @Override - protected void onCreate(Bundle savedInstanceState) { - super.onCreate(savedInstanceState); - GeneratedPluginRegistrant.registerWith(this); - } + @Override + protected void onCreate(Bundle savedInstanceState) { + super.onCreate(savedInstanceState); + GeneratedPluginRegistrant.registerWith(this); +// NearbyConnectionsPlugin.registerWith(this); + } } + +class NearbyConnectionsPlugin implements MethodChannel.MethodCallHandler { + private Activity activity; + private static final String SERVICE_ID = "com.pkmnapps.nearby_connections"; + private static MethodChannel channel; + + private NearbyConnectionsPlugin(Activity activity) { + this.activity = activity; + } + + + public static void registerWith(FlutterActivity activity) { + channel = new MethodChannel(activity.getFlutterView(), "nearby_connections"); + channel.setMethodCallHandler(new NearbyConnectionsPlugin(activity)); + } + + @Override + public void onMethodCall(MethodCall call, final MethodChannel.Result result) { + + switch (call.method) { + case "checkPermissions": + if (ContextCompat.checkSelfPermission(activity, Manifest.permission.ACCESS_FINE_LOCATION) + != PackageManager.PERMISSION_GRANTED || ContextCompat.checkSelfPermission(activity, Manifest.permission.ACCESS_COARSE_LOCATION) + != PackageManager.PERMISSION_GRANTED) { + result.success(false); + } else { + result.success(true); + } + break; + case "askPermissions": + ActivityCompat.requestPermissions(activity, + new String[]{Manifest.permission.ACCESS_FINE_LOCATION, Manifest.permission.ACCESS_COARSE_LOCATION}, + 0); + result.success(null); + break; + case "stopAdvertising": + Nearby.getConnectionsClient(activity).stopAdvertising(); + result.success(null); + break; + case "stopDiscovery": + Log.d("NearbyCon java", "stop discovery"); + Nearby.getConnectionsClient(activity).stopDiscovery(); + result.success(null); + break; + case "startAdvertising": { + String userNickName = (String) call.argument("userNickName"); + int strategy = (int) call.argument("strategy"); + + assert userNickName != null; + AdvertisingOptions advertisingOptions = new AdvertisingOptions.Builder() + .setStrategy(getStrategy(strategy)).build(); + + Nearby.getConnectionsClient(activity) + .startAdvertising( + userNickName, SERVICE_ID, advertConnectionLifecycleCallback, advertisingOptions) + .addOnSuccessListener(new OnSuccessListener() { + @Override + public void onSuccess(Void aVoid) { + result.success(true); + + } + }) + .addOnFailureListener(new OnFailureListener() { + @Override + public void onFailure(@NonNull Exception e) { + result.success(false); + } + }); + break; + } + case "startDiscovery": { + String userNickName = (String) call.argument("userNickName"); + int strategy = (int) call.argument("strategy"); + + assert userNickName != null; + DiscoveryOptions discoveryOptions = + new DiscoveryOptions.Builder().setStrategy(getStrategy(strategy)).build(); + Nearby.getConnectionsClient(activity) + .startDiscovery(SERVICE_ID, endpointDiscoveryCallback, discoveryOptions) + .addOnSuccessListener(new OnSuccessListener() { + @Override + public void onSuccess(Void aVoid) { + result.success(true); + } + }) + .addOnFailureListener(new OnFailureListener() { + @Override + public void onFailure(@NonNull Exception e) { + result.success(false); + } + }); + break; + } + case "stopAllEndpoints": + Log.d("NearbyCon java", "stopAllEndpoints"); + Nearby.getConnectionsClient(activity).stopAllEndpoints(); + result.success(null); + break; + case "disconnectFromEndpoint": { + Log.d("NearbyCon java", "disconnectFromEndpoint"); + String endpointId = call.argument("endpointId"); + assert endpointId != null; + Nearby.getConnectionsClient(activity).disconnectFromEndpoint(endpointId); + result.success(null); + break; + } + case "requestConnection": { + Log.d("NearbyCon java", "requestConnection"); + String userNickName = (String) call.argument("userNickName"); + String endpointId = (String) call.argument("endpointId"); + + assert userNickName != null; + assert endpointId != null; + Nearby.getConnectionsClient(activity) + .requestConnection(userNickName, endpointId, discoverConnectionLifecycleCallback) + .addOnSuccessListener(new OnSuccessListener() { + @Override + public void onSuccess(Void aVoid) { + result.success(true); + } + }) + .addOnFailureListener(new OnFailureListener() { + @Override + public void onFailure(@NonNull Exception e) { + result.error("Failure", e.getMessage(), null); + } + }); + break; + } + case "acceptConnection": { + String endpointId = (String) call.argument("endpointId"); + + assert endpointId != null; + Nearby.getConnectionsClient(activity) + .acceptConnection(endpointId, payloadCallback) + .addOnSuccessListener(new OnSuccessListener() { + @Override + public void onSuccess(Void aVoid) { + result.success(true); + } + }) + .addOnFailureListener(new OnFailureListener() { + @Override + public void onFailure(@NonNull Exception e) { + result.error("Failure", e.getMessage(), null); + } + }); + break; + } + case "rejectConnection": { + String endpointId = (String) call.argument("endpointId"); + + assert endpointId != null; + Nearby.getConnectionsClient(activity) + .rejectConnection(endpointId) + .addOnSuccessListener(new OnSuccessListener() { + @Override + public void onSuccess(Void aVoid) { + result.success(true); + } + }) + .addOnFailureListener(new OnFailureListener() { + @Override + public void onFailure(@NonNull Exception e) { + result.error("Failure", e.getMessage(), null); + } + }); + break; + } + case "sendPayload": { + //Nearby.getConnectionsClient(activity).sendPayload() + break; + } + default: + result.notImplemented(); + } + } + + private final ConnectionLifecycleCallback advertConnectionLifecycleCallback = new ConnectionLifecycleCallback() { + @Override + public void onConnectionInitiated(@NonNull String endpointId, @NonNull ConnectionInfo connectionInfo) { + Log.d("NearbyCon java", "ad.onConnectionInitiated"); + Map args = new HashMap<>(); + args.put("endpointId", endpointId); + args.put("endpointName", connectionInfo.getEndpointName()); + args.put("authenticationToken", connectionInfo.getAuthenticationToken()); + args.put("isIncomingConnection", connectionInfo.isIncomingConnection()); + channel.invokeMethod("ad.onConnectionInitiated", args); + } + + @Override + public void onConnectionResult(@NonNull String endpointId, @NonNull ConnectionResolution connectionResolution) { + Log.d("NearbyCon java", "ad.onConnectionResult"); + Map args = new HashMap<>(); + args.put("endpointId", endpointId); + int statusCode = -1; + switch (connectionResolution.getStatus().getStatusCode()) { + case ConnectionsStatusCodes.STATUS_OK: + statusCode = 0; + // We're connected! Can now start sending and receiving data. + break; + case ConnectionsStatusCodes.STATUS_CONNECTION_REJECTED: + statusCode = 1; + // The connection was rejected by one or both sides. + break; + case ConnectionsStatusCodes.STATUS_ERROR: + statusCode = 2; + // The connection broke before it was able to be accepted. + break; + default: + // Unknown status code + } + args.put("statusCode", statusCode); + channel.invokeMethod("ad.onConnectionResult", args); + } + + @Override + public void onDisconnected(@NonNull String endpointId) { + Log.d("NearbyCon java", "ad.onDisconnected"); + Map args = new HashMap<>(); + args.put("endpointId", endpointId); + channel.invokeMethod("ad.onDisconnected", args); + } + }; + + private final ConnectionLifecycleCallback discoverConnectionLifecycleCallback = new ConnectionLifecycleCallback() { + @Override + public void onConnectionInitiated(@NonNull String endpointId, @NonNull ConnectionInfo connectionInfo) { + Log.d("NearbyCon java", "dis.onConnectionInitiated"); + Map args = new HashMap<>(); + args.put("endpointId", endpointId); + args.put("endpointName", connectionInfo.getEndpointName()); + args.put("authenticationToken", connectionInfo.getAuthenticationToken()); + args.put("isIncomingConnection", connectionInfo.isIncomingConnection()); + channel.invokeMethod("dis.onConnectionInitiated", args); + } + + @Override + public void onConnectionResult(@NonNull String endpointId, @NonNull ConnectionResolution connectionResolution) { + Log.d("NearbyCon java", "dis.onConnectionResult"); + Map args = new HashMap<>(); + args.put("endpointId", endpointId); + int statusCode = -1; + switch (connectionResolution.getStatus().getStatusCode()) { + case ConnectionsStatusCodes.STATUS_OK: + statusCode = 0; + // We're connected! Can now start sending and receiving data. + break; + case ConnectionsStatusCodes.STATUS_CONNECTION_REJECTED: + statusCode = 1; + // The connection was rejected by one or both sides. + break; + case ConnectionsStatusCodes.STATUS_ERROR: + statusCode = 2; + // The connection broke before it was able to be accepted. + break; + default: + // Unknown status code + } + args.put("statusCode", statusCode); + channel.invokeMethod("dis.onConnectionResult", args); + } + + @Override + public void onDisconnected(@NonNull String endpointId) { + Log.d("NearbyCon java", "dis.onDisconnected"); + Map args = new HashMap<>(); + args.put("endpointId", endpointId); + channel.invokeMethod("dis.onDisconnected", args); + } + }; + + private final PayloadCallback payloadCallback = new PayloadCallback() { + @Override + public void onPayloadReceived(@NonNull String s, @NonNull Payload payload) { + + } + + @Override + public void onPayloadTransferUpdate(@NonNull String s, @NonNull PayloadTransferUpdate payloadTransferUpdate) { + + } + }; + + private final EndpointDiscoveryCallback endpointDiscoveryCallback = new EndpointDiscoveryCallback() { + @Override + public void onEndpointFound(@NonNull String endpointId, @NonNull DiscoveredEndpointInfo discoveredEndpointInfo) { + Log.d("NearbyCon java", "onEndpointFound"); + Map args = new HashMap<>(); + args.put("endpointId", endpointId); + args.put("endpointName", discoveredEndpointInfo.getEndpointName()); + args.put("serviceId", discoveredEndpointInfo.getServiceId()); + channel.invokeMethod("dis.onEndpointFound", args); + } + + @Override + public void onEndpointLost(@NonNull String endpointId) { + Log.d("NearbyCon java", "onEndpointLost"); + Map args = new HashMap<>(); + args.put("endpointId", endpointId); + channel.invokeMethod("dis.onEndpointLost", args); + } + }; + + private Strategy getStrategy(int strategy) { + switch (strategy) { + case 0: + return Strategy.P2P_CLUSTER; + case 1: + return Strategy.P2P_STAR; + case 2: + return Strategy.P2P_POINT_TO_POINT; + default: + return Strategy.P2P_CLUSTER; + } + } +} \ No newline at end of file