How to pass accurate GPS location from android studio to unity?

Hi guys! My script returns accurate GPS location on android studio BUT I cant pass the values to C# unity.

 import android.Manifest;
 import android.annotation.TargetApi;
 import android.app.Service;
 import android.content.DialogInterface;
 import android.content.pm.PackageManager;
 import android.location.Criteria;
 import android.location.Location;
 import android.location.LocationListener;
 import android.location.LocationManager;
 import android.os.Build;
 import android.os.Bundle;
 import android.support.v7.app.AppCompatActivity;
 import android.util.Log;
 import android.widget.TextView;
 
 import java.text.DateFormat;
 import java.util.ArrayList;
 
 //////////////////////////////////
     //////////////////////////////////
     public class MainActivity extends AppCompatActivity implements LocationListener {
 
 
         final String TAG = "GPS";
         private final static int ALL_PERMISSIONS_RESULT = 101;
         private static final long MIN_DISTANCE_CHANGE_FOR_UPDATES = 1/100;
         private static final long MIN_TIME_BW_UPDATES = 1;
         //1000 * 60 * 1
         TextView tvLatitude, tvLongitude, tvTime;
         LocationManager locationManager;
         Location loc;
         ArrayList<String> permissions = new ArrayList<>();
         ArrayList<String> permissionsToRequest;
         ArrayList<String> permissionsRejected = new ArrayList<>();
         boolean isGPS = false;
         boolean isNetwork = false;
         boolean canGetLocation = true;
         @Override
         protected void onCreate(Bundle savedInstanceState) {
             super.onCreate(savedInstanceState);
 
 
 
 
             setContentView(R.layout.activity_main);
 
             tvLatitude = (TextView) findViewById(R.id.tvLatitude);
             tvLongitude = (TextView) findViewById(R.id.tvLongitude);
             tvTime = (TextView) findViewById(R.id.tvTime);
 
             locationManager = (LocationManager) getSystemService(Service.LOCATION_SERVICE);
             isGPS = locationManager.isProviderEnabled(LocationManager.GPS_PROVIDER);
             isNetwork = locationManager.isProviderEnabled(LocationManager.NETWORK_PROVIDER);
 
             permissions.add(Manifest.permission.ACCESS_FINE_LOCATION);
             permissions.add(Manifest.permission.ACCESS_COARSE_LOCATION);
             permissionsToRequest = findUnAskedPermissions(permissions);
 
             if (!isGPS && !isNetwork) {
                 Log.d(TAG, "Connection off");
                 // showSettingsAlert();
                 getLastLocation();
             } else {
                 Log.d(TAG, "Connection on");
                 // check permissions
                 if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
                     if (permissionsToRequest.size() > 0) {
                         requestPermissions(permissionsToRequest.toArray(new String[permissionsToRequest.size()]),
                                 ALL_PERMISSIONS_RESULT);
                         Log.d(TAG, "Permission requests");
                         canGetLocation = false;
                     }
                 }
 
                 // get location
                 getLocation();
             }
         }
 
         @Override
         public void  onLocationChanged (Location location) {
             Log.d(TAG, "onLocationChanged");
             updateUI(location);
         }
 
         @Override
         public void onStatusChanged(String s, int i, Bundle bundle) {}
 
         @Override
         public void onProviderEnabled(String s) {
             getLocation();
         }
 
         @Override
         public void onProviderDisabled(String s) {
             if (locationManager != null) {
                 locationManager.removeUpdates(this);
             }
         }
 
         private void getLocation() {
             try {
                 if (canGetLocation) {
                     Log.d(TAG, "Can get location");
                     if (isGPS) {
                         // from GPS
                         Log.d(TAG, "GPS on");
                         locationManager.requestLocationUpdates(
                                 LocationManager.GPS_PROVIDER,
                                 MIN_TIME_BW_UPDATES,
                                 MIN_DISTANCE_CHANGE_FOR_UPDATES, this);
 
                         if (locationManager != null) {
                             loc = locationManager.getLastKnownLocation(LocationManager.GPS_PROVIDER);
                             if (loc != null)
                                 updateUI(loc);
                         }
                     } else if (isNetwork) {
                         // from Network Provider
                         Log.d(TAG, "NETWORK_PROVIDER on");
                         locationManager.requestLocationUpdates(
                                 LocationManager.NETWORK_PROVIDER,
                                 MIN_TIME_BW_UPDATES,
                                 MIN_DISTANCE_CHANGE_FOR_UPDATES, this);
 
                         if (locationManager != null) {
                             loc = locationManager.getLastKnownLocation(LocationManager.NETWORK_PROVIDER);
                             if (loc != null)
                                 updateUI(loc);
                         }
                     } else {
                         loc.setLatitude(0);
                         loc.setLongitude(0);
                         updateUI(loc);
                     }
                 } else {
                     Log.d(TAG, "Can't get location");
                 }
             } catch (SecurityException e) {
                 e.printStackTrace();
             }
         }
 
         private void getLastLocation() {
             try {
                 Criteria criteria = new Criteria();
                 String provider = locationManager.getBestProvider(criteria, false);
                 Location location = locationManager.getLastKnownLocation(provider);
                 Log.d(TAG, provider);
                 Log.d(TAG, location == null ? "NO LastLocation" : location.toString());
             } catch (SecurityException e) {
                 e.printStackTrace();
             }
         }
 
         private ArrayList findUnAskedPermissions(ArrayList<String> wanted) {
             ArrayList result = new ArrayList();
 
 
             for (String perm : wanted) {
                 if (!hasPermission(perm)) {
                     result.add(perm);
                 }
             }
 
             return result;
         }
 
         private boolean hasPermission(String permission) {
             if (canAskPermission()) {
                 if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
                     return (checkSelfPermission(permission) == PackageManager.PERMISSION_GRANTED);
                 }
             }
             return true;
         }
 
         private boolean canAskPermission() {
             return (Build.VERSION.SDK_INT > Build.VERSION_CODES.LOLLIPOP_MR1);
         }
 
         @TargetApi(Build.VERSION_CODES.M)
         @Override
         public void onRequestPermissionsResult(int requestCode, String[] permissions, int[] grantResults) {
             switch (requestCode) {
                 case ALL_PERMISSIONS_RESULT:
                     Log.d(TAG, "onRequestPermissionsResult");
                     for (String perms : permissionsToRequest) {
                         if (!hasPermission(perms)) {
                             permissionsRejected.add(perms);
                         }
                     }
 
                     if (permissionsRejected.size() > 0) {
                         if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
                             if (shouldShowRequestPermissionRationale(permissionsRejected.get(0))) {
 //                                showMessageOKCancel("These permissions are mandatory for the application. Please allow access.",
                                         new DialogInterface.OnClickListener() {
                                             @Override
                                             public void onClick(DialogInterface dialog, int which) {
                                                 if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
                                                     requestPermissions(permissionsRejected.toArray(
                                                             new String[permissionsRejected.size()]), ALL_PERMISSIONS_RESULT);
                                                 }
                                             }
                                         };
                                 return;
                             }
                         }
                     } else {
                         Log.d(TAG, "No rejected permissions.");
                         canGetLocation = true;
                         getLocation();
                     }
                     break;
             }
         }
 
 
         private void  updateUI (Location loc) {
             Log.d(TAG, "updateUI");
             tvLatitude.setText(Double.toString(loc.getLatitude()));
             String LA =(Double.toString(loc.getLatitude()));
             String LO =(Double.toString(loc.getLongitude()));
 
               tvLongitude.setText(Double.toString(loc.getLongitude()));
              tvTime.setText(DateFormat.getTimeInstance().format(loc.getTime()));
             //  return LA ;
 
 
 
 
         }
 
         @Override
         protected void onDestroy() {
             super.onDestroy();
             if (locationManager != null) {
                 locationManager.removeUpdates(this);
             }
         }
     }