Migrate from 100.x to 200.x

override fun onCreate(savedInstanceState: Bundle?) {
    super.onCreate(savedInstanceState)
    // set the API key
    ArcGISEnvironment.apiKey = ApiKey.create(BuildConfig.YOUR_ACCESS_TOKEN)
    // set up data binding for the activity
    val activityMainBinding: ActivityMainBinding = DataBindingUtil.setContentView(this, R.layout.activity_main)
    mapView = activityMainBinding.mapView
    // add the MapView to the activity's lifecycle
    lifecycle.addObserver(mapView)
}

override fun onCreate(savedInstanceState: Bundle?) {
    super.onCreate(savedInstanceState)
    val activityMainBinding = ActivityMainBinding.inflate(layoutInflater)
    setContentView(activityMainBinding.root)
    // set the API key
    ArcGISRuntimeEnvironment.setApiKey(BuildConfig.API_KEY)
    // view binding of MapView to value
    mapView =  activityMainBinding.mapView

}

override fun onPause() {
    mapView.pause()
    super.onPause()
}

override fun onResume() {
    super.onResume()
    mapView.resume()
}

override fun onDestroy() {
    mapView.dispose()
    super.onDestroy()
}

coroutineScope.launch {
    // run the suspend function to get a geodatabase
    val geodatabaseResult = Geodatabase.create(filePath)
    // get the result once suspend is completed
    geodatabaseResult.onSuccess { geodatabase ->
        // run the suspend function to create a geodatabase feature table
        val featureTableResult = geodatabase.createTable(tableDescription)
        // get the result once suspend is completed
        featureTableResult.onSuccess { geodatabaseFeatureTable ->
            setupMapFromGeodatabase(geodatabaseFeatureTable)
        }.onFailure { throwable ->
            showMessage(throwable.message)
        }
    }.onFailure { throwable ->
        showMessage(throwable.message)
    }
}

val geodatabaseFuture = Geodatabase.createAsync(filePath)
// create the geodatabase asynchronously
geodatabaseFuture.addDoneListener {
    try {
        // get the instance of the mobile geodatabase
        val geodatabase = geodatabaseFuture.get()
        // make a future to create a table using the table description
        val featureTableFuture = geodatabase.createTableAsync(tableDescription)
        featureTableFuture.addDoneListener {
            try {
                // get the created feature table
                val featureTable = featureTableFuture.get()
                setupMapFromGeodatabase(featureTable)
            } catch (e: Exception) {
                showMessage(e.message)
            }
        }
    } catch (e: Exception) {
        showMessage(e.message)
    }
}

val simulatedLocationDataSource = SimulatedLocationDataSource(polyline)
simulatedLocationDataSource.start()
simulatedLocationDataSource.locationChanged.collect { location ->
    val locationPoint = location.position
}

val simulatedLocationDataSource = SimulatedLocationDataSource().apply {
    setLocations(polyline)
}
simulatedLocationDataSource.startAsync()
simulatedLocationDataSource.addLocationChangedListener { locationChangedEvent ->
    val locationPoint = locationChangedEvent.location.position
}

private suspend fun loadPortalItem() {
    val portalItem = PortalItem(Portal("https://www.arcgis.com"), itemID)
    portalItem.load().onSuccess {
        val featureLayer = FeatureLayer.createWithItem(portalItem)
        setFeatureLayer(featureLayer, viewpoint)
    }.onFailure { throwable ->
        showError(throwable.message)
    }
}

private fun loadPortalItem() {
    val portal = Portal("https://www.arcgis.com", false)
    val portalItem = PortalItem(portal, itemID)
    portalItem.addDoneLoadingListener {
        if(portalItem.loadStatus == LoadStatus.LOADED){
            val featureLayer = FeatureLayer(portalItem)
            setFeatureLayer(featureLayer)
        }else if(portalItem.loadStatus == LoadStatus.FAILED_TO_LOAD){
            showError(portalItem.loadError.message)
        }
    }
    portalItem.loadAsync()
}

// create a new offline map task
val offlineMapTask = OfflineMapTask(map)
// set the parameters of the task
val generateOfflineMapParameters = GenerateOfflineMapParameters(
        areaOfInterest = geometry,
        minScale = minScale,
        maxScale = maxScale
)
// create a job with the offline map parameters
val offlineMapJob = offlineMapTask.createGenerateOfflineMapJob(
    parameters = generateOfflineMapParameters,
    downloadDirectoryPath = offlineMapPath
)
// start the job
offlineMapJob.start()
with (coroutineScope) {
    // collect the progress of the job
    launch {
        offlineMapJob.progress.collect {
            val progressPercentage = offlineMapJob.progress.value
        }
    }
    // display map if job succeeds
    launch {
        offlineMapJob.result().onSuccess { generateOfflineMapResult ->

            map = generateOfflineMapResult.offlineMap

        }.onFailure { throwable ->
            showMessage(throwable.message.toString())
        }
    }
}

// create a new offline map task
val offlineMapTask = OfflineMapTask(map)
// set the parameters of the task
val generateOfflineMapParameters = GenerateOfflineMapParameters(
    geometry, minScale, maxScale
)
// create a job with the offline map parameters
val offlineMapJob = offlineMapTask.generateOfflineMap(
    generateOfflineMapParameters,
    offlineMapPath
)
// start the job
offlineMapJob.start()
// get the progress of the job
offlineMapJob.addProgressChangedListener {
    val progress = offlineMapJob.progress
}
// display map if job succeeds
offlineMapJob.addJobDoneListener {
    if (offlineMapJob.status == Job.Status.SUCCEEDED) {
        map = offlineMapJob.result.offlineMap
    } else if (offlineMapJob.status == Job.Status.FAILED) {
        showMessage(offlineMapJob.error.message)
    }
}

// Make a polyline geometry
val polylineGeometry = PolylineBuilder(spatialReference) {
    addPoint(x = -10e5, y = 40e5)
    addPoint(x = 20e5, y = 50e5)
}.toGeometry()

// Make a part geometry using segments
val partGeometry = MutablePart.createWithSegments(
    segments = listOf(leftCurve, leftArc, rightArc, rightCurve),
    spatialReference = spatialReference
)
val polygon = Polygon(listOf(partGeometry))

// Make a polyline geometry
val polylineGeometry = PolylineBuilder(spatialReference).apply {
    addPoint(x = -10e5, y = 40e5)
    addPoint(x= 20e5, y = 50e5)
}.toGeometry()

// Make a part geometry using segments
val partGeometry = MutablePart(spatialReference).apply {
    addAll(listOf(leftCurve,leftArc,rightArc,rightCurve))
}
val polyon = Polygon(partGeometry, spatialReference)

    MapView(
        modifier = Modifier.fillMaxSize(),
        arcGISMap = map,
        onSingleTapConfirmed = { singleTapConfirmedEvent ->
          val mapPoint = singleTapConfirmedEvent.mapPoint
          val screenCoordinate = singleTapConfirmedEvent.screenCoordinate
          // . . .
        }
    )

mapView.onTouchListener = object : DefaultMapViewOnTouchListener(applicationContext, mapView) {
      override fun onSingleTapConfirmed(motionEvent: MotionEvent): Boolean {
          val screenPoint = android.graphics.Point(
              motionEvent.x.roundToInt(),
              motionEvent.y.roundToInt()
          )
          val mapPoint = mapView.screenToLocation(screenPoint)
          return super.onSingleTapConfirmed(motionEvent)
      }
  }