Geofence funktioniert nicht in Kotlin

Question

Geofence funktioniert nicht in Kotlin, obwohl der gleiche Code in Java funktioniert. Ich bin ein Neuling nach Kotlin und daher nicht in der Lage, das Problem zu verstehen. Eigentlich ich MainGeofence.kt Dienstklasse aus einer Tätigkeit anzurufenden MainActivity finden Sie den Code

MainGeofence.kt

public class MainGeofence : IntentService("MyService"), LocationListener { 

    internal var mGeofencePendingIntent: PendingIntent? = null 
    private var mGeofenceList: ArrayList<Geofence>? = null 
    private var mGoogleApiClient: GoogleApiClient? = null 
    val TAG = "Activity" 
    internal lateinit var mLocationRequest: LocationRequest 
    internal var currentLatitude = <<lat value 
    internal var currentLongitude = <<long value 

    override fun onCreate() { 
     super.onCreate() 
    } 

    override fun onHandleIntent(p0: Intent?) { 
     mGeofenceList = ArrayList<Geofence>() 

     if (GoogleApiAvailability.getInstance().isGooglePlayServicesAvailable(this) 
       == ConnectionResult.SUCCESS) { 
      initGoogleAPIClient() 

      createGeofences(currentLatitude, currentLongitude) 
     } else { 
      Log.e(TAG, "Your Device doesn't support Google Play Services.") 
     } 

     mLocationRequest = LocationRequest.create() 
       .setPriority(LocationRequest.PRIORITY_HIGH_ACCURACY) 
       .setInterval(1 * 1000) 
       .setFastestInterval(1 * 1000) 
    } 

    public fun initGoogleAPIClient(): Unit { 
     mGoogleApiClient = GoogleApiClient.Builder(this) 
       .addApi(API) 
       .addConnectionCallbacks(connectionAddListener) 
       .addOnConnectionFailedListener(connectionFailedListener) 
       .build() 
     mGoogleApiClient?.connect() 
    } 

    private val connectionAddListener = object : GoogleApiClient.ConnectionCallbacks { 
     @SuppressLint("MissingPermission") 
     override fun onConnected(bundle: Bundle?) { 
      Log.i(TAG, "onConnected") 

      @SuppressLint("MissingPermission") 
      val location = FusedLocationApi.getLastLocation(mGoogleApiClient) 

      if (location == null) { 
       FusedLocationApi.requestLocationUpdates(mGoogleApiClient, mLocationRequest, this@MainGeofence) 
      } else { 
       //If everything went fine lets get latitude and longitude 
       currentLatitude = location.latitude 
       currentLongitude = location.longitude 

       Log.i(TAG, currentLatitude.toString() + " WORKS " + currentLongitude) 

       //createGeofences(currentLatitude, currentLongitude); 
       //registerGeofences(mGeofenceList); 
      } 

      try { 
       GeofencingApi.addGeofences(
         mGoogleApiClient, 
         getGeofencingRequest(), 
         getGeofencePendingIntent() 
       ).setResultCallback(ResultCallback<Status> { status -> 
        if (status.isSuccess) { 
         Log.i(TAG, "Saving Geofence") 

        } else { 
         Log.e(TAG, "Registering geofence failed: " + status.statusMessage + 
           " : " + status.statusCode) 
        } 
       }) 

      } catch (securityException: SecurityException) { 
       // Catch exception generated if the app does not use ACCESS_FINE_LOCATION permission. 
       Log.e(TAG, "Error") 
      } 

     } 

     override fun onConnectionSuspended(i: Int) { 

      Log.e(TAG, "onConnectionSuspended") 

     } 
    } 

    /** 
    * Create a Geofence list 
    */ 
    fun createGeofences(latitude: Double, longitude: Double) { 
     val id = UUID.randomUUID().toString() 
     println("latnlon " + latitude + " " + longitude) 
     val fence = Geofence.Builder() 
       .setRequestId(id) 
       .setTransitionTypes(Geofence.GEOFENCE_TRANSITION_ENTER or Geofence.GEOFENCE_TRANSITION_EXIT) 
       .setCircularRegion(latitude, longitude, 50f) 
       .setExpirationDuration(Geofence.NEVER_EXPIRE) 
       .build() 
     mGeofenceList?.add(fence) 
    } 

    private fun getGeofencingRequest(): GeofencingRequest { 
     val builder = GeofencingRequest.Builder() 
     builder.setInitialTrigger(GeofencingRequest.INITIAL_TRIGGER_ENTER) 
     builder.addGeofences(mGeofenceList) 
     return builder.build() 
    } 

    private fun getGeofencePendingIntent(): PendingIntent { 
     // Reuse the PendingIntent if we already have it. 
     if (mGeofencePendingIntent != null) { 
      return mGeofencePendingIntent!! 
     } 
     val intent = Intent(this, GeofenceIntentService::class.java) 
     // We use FLAG_UPDATE_CURRENT so that we get the same pending intent back when 
     // calling addGeofences() and removeGeofences(). 
     return PendingIntent.getService(this, 0, intent, PendingIntent.FLAG_UPDATE_CURRENT) 
    } 

    private val connectionFailedListener = GoogleApiClient.OnConnectionFailedListener { Log.e(TAG, "onConnectionFailed") } 

    override fun onLocationChanged(location: Location?) { 

     if (location != null) { 
      currentLatitude = location.latitude 
      currentLongitude = location.longitude 
      Log.i(TAG, "onLocationChanged") 
     } 
    } 

} 

MainActivity.kt

override fun onCreate(savedInstanceState: Bundle?) { 
     super.onCreate(savedInstanceState) 
     setContentView(R.layout.activity_main) 
     dummyBtn = findViewById(R.id.dummyBtn) 
     dummyTv = findViewById(R.id.dummyTv) 

     dummyBtn.setOnClickListener(View.OnClickListener { 
      //   startLocationUpdates() 
      startService(Intent(this, MainGeofence::class.java)) 
       ... 
     }) 
       .... 
    } 

und GeofenceIntentService.kt

public class GeofenceIntentService : IntentService("GeofenceIntentService") { 

    private final var TAG: String = "Geofence" 

    override fun onHandleIntent(intent: Intent?) { 
     Log.i(TAG, "onHandleIntent") 
     val geofencingEvent = fromIntent(intent) 
     if (geofencingEvent.hasError()) { 
      Log.e(TAG, "Goefencing Error " + geofencingEvent.errorCode) 
      return 
     } 
     //Create AudioManager object to change phone profile 
     var am: AudioManager = getSystemService(Context.AUDIO_SERVICE) as AudioManager 
     // Get the transition type. 
     val geofenceTransition = geofencingEvent.geofenceTransition 
     Log.i(TAG, "geofenceTransition = " + geofenceTransition + " Enter : " + 
       Geofence.GEOFENCE_TRANSITION_ENTER + "Exit : " + Geofence.GEOFENCE_TRANSITION_EXIT) 
     when (geofenceTransition) { 

      Geofence.GEOFENCE_TRANSITION_ENTER or Geofence.GEOFENCE_TRANSITION_DWELL -> { 
       showNotification("Entered", "Entered the Location") 
       am.setRingerMode(AudioManager.RINGER_MODE_VIBRATE) //put ringer to vibration 
      } 
      Geofence.GEOFENCE_TRANSITION_EXIT -> { 
       showNotification("Exited", "Exited the Location") 
       am.setRingerMode(AudioManager.RINGER_MODE_NORMAL) //put ringer to normal 
      } 
      else -> { 
       println("oh cow's eye! something bad happened!") 
       Log.e(TAG, "Error ") 
      } 
     } 

    } 

    fun showNotification(text: String, bigText: String) { 

     // 1. Create a NotificationManager 
     val notificationManager = this.getSystemService(Context.NOTIFICATION_SERVICE) as NotificationManager 

     // 2. Create a PendingIntent for AllGeofencesActivity 
     val intent = Intent(this, MainActivity::class.java) 
     intent.addFlags(Intent.FLAG_ACTIVITY_SINGLE_TOP or Intent.FLAG_ACTIVITY_CLEAR_TOP) 
     val pendingNotificationIntent = PendingIntent.getActivity(this, 0, 
       intent, PendingIntent.FLAG_UPDATE_CURRENT) 

     // 3. Create and send a notification 
     val notification = NotificationCompat.Builder(this) 
       .setSmallIcon(R.mipmap.ic_launcher) 
       .setContentTitle("Title") 
       .setContentText(text) 
       .setContentIntent(pendingNotificationIntent) 
       .setStyle(NotificationCompat.BigTextStyle().bigText(bigText)) 
       .setPriority(NotificationCompat.PRIORITY_HIGH) 
       .setAutoCancel(true) 
       .build() 
     notificationManager.notify(0, notification) 
    } 

} 

Geofence Punkte selten Feuer und das auch nur Exit eins. Aber Code funktioniert perfekt in Java. Ist das Problem der Sprache oder Implementierung? Hilfe wird sehr geschätzt!

Answer 1

Ich denke, Ihr Problem ist die, wenn Klausel in onHandleIntent

Sie haben im Wesentlichen

when (x) { 
     A or B -> { ... } 
     C -> { ... } 
     else -> { ... } 
} 

Ich denke, Geofence.GEOFENCE_TRANSITION_ENTER etc sind Int Typen so dass Sie enden Aufruf „bit- oder“ auf ihnen infix fun or(other: Int): Int (source) mit .

Ich denke, was Sie wirklich wollen, ist:

when (x) { 
     A, B -> { ... } 
     C -> { ... } 
     else -> { ... } 
}