diff --git a/positioning/app/build.gradle b/positioning/app/build.gradle
index 30e82d24..84ef883a 100644
--- a/positioning/app/build.gradle
+++ b/positioning/app/build.gradle
@@ -1,4 +1,5 @@
 apply plugin: 'com.android.application'
+apply plugin: 'kotlin-android'
 
 android {
     compileSdkVersion 33
@@ -25,9 +26,24 @@ repositories {
     flatDir {
         dirs 'libs'
     }
+    mavenCentral()
 }
 
 dependencies {
     implementation(name: 'HERE-sdk', ext: 'aar')
-    implementation 'androidx.appcompat:appcompat:1.2.0'
+    implementation 'androidx.appcompat:appcompat:1.5.1'
+    implementation "androidx.core:core-ktx:1.9.0"
+    implementation "org.jetbrains.kotlin:kotlin-stdlib-jdk7:$kotlin_version"
+    implementation "org.jetbrains.kotlinx:kotlinx-coroutines-core:1.6.1"
+    implementation "org.jetbrains.kotlinx:kotlinx-coroutines-android:1.6.1"
+    implementation "org.jetbrains.kotlinx:kotlinx-coroutines-core-jvm:1.6.1"
+
+
+    annotationProcessor "androidx.lifecycle:lifecycle-compiler:2.4.1"
+    implementation "androidx.lifecycle:lifecycle-common-java8:2.4.1"
+    implementation "androidx.lifecycle:lifecycle-runtime-ktx:2.4.1"
+    implementation "androidx.lifecycle:lifecycle-livedata-ktx:2.4.1"
+    implementation "androidx.lifecycle:lifecycle-viewmodel-ktx:2.4.1"
+    //implementation "androidx.lifecycle:lifecycle-extensions:2.4.1"
+
 }
diff --git a/positioning/app/src/main/AndroidManifest.xml b/positioning/app/src/main/AndroidManifest.xml
index c0529e05..8253cabd 100644
--- a/positioning/app/src/main/AndroidManifest.xml
+++ b/positioning/app/src/main/AndroidManifest.xml
@@ -39,13 +39,13 @@
          at https://developer.here.com/develop/mobile-sdks-->
         <meta-data
             android:name="com.here.android.maps.appid"
-            android:value="{YOUR_APP_ID}" />
+            android:value="${hereAppId}" />
         <meta-data
             android:name="com.here.android.maps.apptoken"
-            android:value="{YOUR_APP_CODE}" />
+            android:value="${hereAppToken}" />
         <meta-data
             android:name="com.here.android.maps.license.key"
-            android:value="{YOUR_LICENSE_KEY}" />
+            android:value="${hereKey}" />
         <!--
             Embed the HERE Positioning Service.
             For more information, see the HERE Mobile SDK Developer's Guide
diff --git a/positioning/app/src/main/java/com/here/android/example/basicpositioningsolution/ArrowState.kt b/positioning/app/src/main/java/com/here/android/example/basicpositioningsolution/ArrowState.kt
new file mode 100644
index 00000000..09a698be
--- /dev/null
+++ b/positioning/app/src/main/java/com/here/android/example/basicpositioningsolution/ArrowState.kt
@@ -0,0 +1,3 @@
+package com.here.android.example.basicpositioningsolution
+
+data class ArrowState(@JvmField val angle: Float, @JvmField val tilt: Float)
\ No newline at end of file
diff --git a/positioning/app/src/main/java/com/here/android/example/basicpositioningsolution/BasicPositioningActivity.java b/positioning/app/src/main/java/com/here/android/example/basicpositioningsolution/BasicPositioningActivity.java
index 1822b5dd..6d5006b0 100644
--- a/positioning/app/src/main/java/com/here/android/example/basicpositioningsolution/BasicPositioningActivity.java
+++ b/positioning/app/src/main/java/com/here/android/example/basicpositioningsolution/BasicPositioningActivity.java
@@ -16,17 +16,16 @@
 
 package com.here.android.example.basicpositioningsolution;
 
+import static com.here.android.example.basicpositioningsolution.HereHelperKt.getArrowBitmap;
+
 import android.Manifest;
-import android.os.Bundle;
-import androidx.appcompat.app.AppCompatActivity;
 import android.app.AlertDialog;
 import android.content.Context;
 import android.content.DialogInterface;
-import android.content.pm.ApplicationInfo;
 import android.content.pm.PackageManager;
+import android.graphics.Bitmap;
 import android.os.Build;
-import androidx.annotation.NonNull;
-import androidx.core.app.ActivityCompat;
+import android.os.Bundle;
 import android.util.Log;
 import android.view.Menu;
 import android.view.MenuInflater;
@@ -34,17 +33,25 @@
 import android.widget.TextView;
 import android.widget.Toast;
 
+import androidx.annotation.NonNull;
+import androidx.appcompat.app.AppCompatActivity;
+import androidx.core.app.ActivityCompat;
+import androidx.lifecycle.ViewModelProvider;
+
 import com.here.android.mpa.common.GeoCoordinate;
 import com.here.android.mpa.common.GeoPosition;
+import com.here.android.mpa.common.Image;
 import com.here.android.mpa.common.LocationDataSourceHERE;
 import com.here.android.mpa.common.OnEngineInitListener;
 import com.here.android.mpa.common.PositioningManager;
-import com.here.android.mpa.mapping.Map;
+import com.here.android.mpa.guidance.MapMatcherMode;
+import com.here.android.mpa.guidance.NavigationManager;
 import com.here.android.mpa.mapping.AndroidXMapFragment;
+import com.here.android.mpa.mapping.Map;
 import com.here.android.mpa.mapping.MapState;
+import com.here.android.mpa.mapping.PositionIndicator;
 import com.here.android.positioning.StatusListener;
 
-import java.io.File;
 import java.lang.ref.WeakReference;
 import java.util.Locale;
 
@@ -81,10 +88,19 @@ public class BasicPositioningActivity extends AppCompatActivity implements Posit
     // text view instance for showing location information
     private TextView mLocationInfo;
 
+    private MapViewModel mapViewModel;
+    private Bitmap arrowBitmap;
+    private Image positionImage;
+    private PositionIndicator positionIndicator;
+    private NavigationManager navigationManager;
+
     @Override
     public void onCreate(Bundle savedInstanceState) {
         super.onCreate(savedInstanceState);
 
+        arrowBitmap = getArrowBitmap(this);
+        mapViewModel = new ViewModelProvider(this).get(MapViewModel.class);
+
         if (hasPermissions(this, RUNTIME_PERMISSIONS)) {
             initializeMapsAndPositioning();
         } else {
@@ -136,6 +152,7 @@ public boolean onOptionsItemSelected(MenuItem item) {
 
     @Override
     public void onPositionUpdated(final PositioningManager.LocationMethod locationMethod, final GeoPosition geoPosition, final boolean mapMatched) {
+        mapViewModel.onHeading(geoPosition.getHeading());
         final GeoCoordinate coordinate = geoPosition.getCoordinate();
         if (mTransforming) {
             mPendingUpdate = new Runnable() {
@@ -225,6 +242,17 @@ private AndroidXMapFragment getMapFragment() {
         return (AndroidXMapFragment)getSupportFragmentManager().findFragmentById(R.id.mapfragment);
     }
 
+    public void onArrowCallback(ArrowState arrowState) {
+        Log.d("ArrowState", "Rotating: " + (arrowState.angle) + ", Tilt: " +  arrowState.tilt);
+            if (arrowBitmap != null) {
+                if (arrowState.angle == 0f && arrowState.tilt == 0f) {
+                    positionImage.setBitmap(arrowBitmap);
+                } else {
+                    HereHelperKt.rotateAndSkewImage(positionImage, arrowBitmap, arrowState.angle, arrowState.tilt);
+                }
+            }
+        positionIndicator.setMarker(positionImage);
+    }
     /**
      * Initializes HERE Maps and HERE Positioning. Called after permission check.
      */
@@ -239,9 +267,20 @@ private void initializeMapsAndPositioning() {
             public void onEngineInitializationCompleted(OnEngineInitListener.Error error) {
                 if (error == OnEngineInitListener.Error.NONE) {
                     map = mapFragment.getMap();
+                    mapViewModel.addMap(map);
+                    mapViewModel.setArrowCallback(arrowState -> {
+                        onArrowCallback(arrowState);
+                        return null;
+                    });
+                    positionImage = new Image();
+                    positionImage.setBitmap(arrowBitmap);
                     map.setCenter(new GeoCoordinate(61.497961, 23.763606, 0.0), Map.Animation.NONE);
                     map.setZoomLevel(map.getMaxZoomLevel() - 1);
                     map.addTransformListener(BasicPositioningActivity.this);
+                    mapFragment.getMapGesture().addOnGestureListener(new MapGestureListener((userAction) -> {
+                        mapViewModel.onUserAction(userAction);
+                        return null;
+                    }), 0, false);
                     mPositioningManager = PositioningManager.getInstance();
                     mHereLocation = LocationDataSourceHERE.getInstance(
                             new StatusListener() {
@@ -305,12 +344,20 @@ public void onWifiIndoorPositioningDegraded() {
                         Toast.makeText(BasicPositioningActivity.this, "LocationDataSourceHERE.getInstance(): failed, exiting", Toast.LENGTH_LONG).show();
                         finish();
                     }
+
+                    // Need this to get heading
+                    navigationManager = NavigationManager.getInstance();
+                    navigationManager.startTracking(MapMatcherMode.CAR);
+
                     mPositioningManager.setDataSource(mHereLocation);
                     mPositioningManager.addListener(new WeakReference<PositioningManager.OnPositionChangedListener>(
                             BasicPositioningActivity.this));
                     // start position updates, accepting GPS, network or indoor positions
                     if (mPositioningManager.start(PositioningManager.LocationMethod.GPS_NETWORK_INDOOR)) {
-                        mapFragment.getPositionIndicator().setVisible(true);
+                        positionIndicator = mapFragment.getPositionIndicator();
+                        positionIndicator.setVisible(true);
+                        positionIndicator.setSmoothPositionChange(true);
+                        positionIndicator.setMarker(positionImage);
                     } else {
                         Toast.makeText(BasicPositioningActivity.this, "PositioningManager.start: failed, exiting", Toast.LENGTH_LONG).show();
                         finish();
diff --git a/positioning/app/src/main/java/com/here/android/example/basicpositioningsolution/HereHelper.kt b/positioning/app/src/main/java/com/here/android/example/basicpositioningsolution/HereHelper.kt
new file mode 100644
index 00000000..02270dc1
--- /dev/null
+++ b/positioning/app/src/main/java/com/here/android/example/basicpositioningsolution/HereHelper.kt
@@ -0,0 +1,112 @@
+package com.here.android.example.basicpositioningsolution
+
+import android.content.Context
+import android.graphics.Bitmap
+import android.graphics.Camera
+import android.graphics.Canvas
+import android.graphics.Matrix
+import androidx.annotation.DrawableRes
+import androidx.core.content.ContextCompat
+import com.here.android.mpa.common.Image
+import com.here.android.mpa.mapping.Map
+import com.here.android.mpa.mapping.MapState
+import kotlinx.coroutines.channels.awaitClose
+import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.flow.callbackFlow
+import kotlinx.coroutines.flow.combine
+import kotlinx.coroutines.flow.conflate
+import kotlinx.coroutines.flow.map
+import kotlinx.coroutines.flow.scan
+
+fun Context.getBitmapFromVectorDrawable(@DrawableRes drawableId: Int): Bitmap {
+    val drawable = ContextCompat.getDrawable(this, drawableId)
+    val bitmap = Bitmap.createBitmap(
+        drawable!!.intrinsicWidth,
+        drawable.intrinsicHeight, Bitmap.Config.ARGB_8888
+    )
+    val canvas = Canvas(bitmap)
+    drawable.setBounds(0, 0, canvas.width, canvas.height)
+    drawable.draw(canvas)
+    return bitmap
+}
+
+fun Image.rotateAndSkewImage(srcBitmap: Bitmap, angle: Float, tilt: Float) {
+    val old = bitmap
+    setBitmap(srcBitmap.rotateAndSkewBitmap(angle, tilt))
+    old?.recycle()
+}
+
+fun Bitmap.rotateAndSkewBitmap(angle: Float, tilt: Float): Bitmap {
+    val transformationCamera = Camera()
+    val matrix = Matrix()
+    transformationCamera.rotateX(-tilt);
+    transformationCamera.rotateY(0f);
+    transformationCamera.rotateZ(0f);
+    transformationCamera.getMatrix(matrix);
+
+    val centerX = this.width / 2f;
+    val centerY = this.height / 2f;
+    matrix.preRotate(angle)
+    matrix.preTranslate(-centerX, -centerY)
+    matrix.postTranslate(centerX, centerY)
+
+    return Bitmap.createBitmap(this, 0, 0, width, height, matrix, true)
+}
+
+fun getArrowBitmap(context: Context):Bitmap {
+    return context.getBitmapFromVectorDrawable(R.drawable.ic_map_arrow)
+}
+
+val Map.mapTransformationStateFlow: Flow<MapTransformationState>
+    get() = trackMapTransform()
+        .let { combine(it, it.scanCountActiveTransform(), ::Pair) }
+        .conflate()
+        .map { (event, count) ->
+            when (event) {
+                MapTransformEvent.MapTransformStart ->
+                    MapTransformationState(
+                        activeTransformationCount = count.toInt(),
+                        mapState = null
+                    )
+                is MapTransformEvent.MapTransformEnd -> {
+                    MapTransformationState(
+                        activeTransformationCount = count.toInt(),
+                        mapState = event.mapState
+                    )
+                }
+            }
+        }
+
+data class MapTransformationState(
+    val activeTransformationCount: Int,
+    val mapState: MapState? = null
+)
+
+sealed class MapTransformEvent {
+    object MapTransformStart : MapTransformEvent()
+    data class MapTransformEnd(val mapState: MapState) : MapTransformEvent()
+}
+
+
+fun Map.trackMapTransform(): Flow<MapTransformEvent> =
+    callbackFlow {
+        val listener = object : Map.OnTransformListener {
+            override fun onMapTransformStart() {
+                trySend(MapTransformEvent.MapTransformStart)
+            }
+
+            override fun onMapTransformEnd(mapState: MapState) {
+                trySend(MapTransformEvent.MapTransformEnd(mapState))
+            }
+        }
+        addTransformListener(listener)
+        awaitClose { removeTransformListener(listener) }
+    }
+
+fun Flow<MapTransformEvent>.scanCountActiveTransform(): Flow<Long> =
+    scan(0L) { acc, event ->
+        return@scan when (event) {
+            is MapTransformEvent.MapTransformEnd -> (acc - 1).coerceAtLeast(0)
+            MapTransformEvent.MapTransformStart -> acc + 1
+        }
+    }.conflate()
\ No newline at end of file
diff --git a/positioning/app/src/main/java/com/here/android/example/basicpositioningsolution/MapGestureListener.kt b/positioning/app/src/main/java/com/here/android/example/basicpositioningsolution/MapGestureListener.kt
new file mode 100644
index 00000000..37dd4f13
--- /dev/null
+++ b/positioning/app/src/main/java/com/here/android/example/basicpositioningsolution/MapGestureListener.kt
@@ -0,0 +1,79 @@
+package com.here.android.example.basicpositioningsolution
+
+import android.graphics.PointF
+import com.here.android.mpa.common.ViewObject
+import com.here.android.mpa.mapping.MapGesture
+
+internal class MapGestureListener(
+    private val userAction: (mapUserAction: MapUserAction) -> Unit
+) : MapGesture.OnGestureListener {
+
+
+    override fun onPanStart() {
+        userAction(MapUserAction.CONTINUOUS_ACTION_STARTED)
+    }
+
+    override fun onPanEnd() {
+        userAction(MapUserAction.CONTINUOUS_ACTION_FINISHED)
+    }
+
+    override fun onMultiFingerManipulationStart() {
+        userAction(MapUserAction.CONTINUOUS_ACTION_STARTED)
+    }
+
+    override fun onMultiFingerManipulationEnd() {
+        userAction(MapUserAction.CONTINUOUS_ACTION_FINISHED)
+    }
+
+    override fun onMapObjectsSelected(p0: MutableList<ViewObject>): Boolean {
+        userAction(MapUserAction.ONE_TIME_ACTION)
+        return false
+    }
+
+    override fun onTapEvent(p0: PointF): Boolean {
+        userAction(MapUserAction.ONE_TIME_ACTION)
+        return false
+    }
+
+    override fun onDoubleTapEvent(p0: PointF): Boolean {
+        userAction(MapUserAction.ONE_TIME_ACTION)
+        return false
+    }
+
+    override fun onPinchLocked() {
+        userAction(MapUserAction.ONE_TIME_ACTION)
+    }
+
+    override fun onPinchZoomEvent(p0: Float, p1: PointF): Boolean {
+        userAction(MapUserAction.ONE_TIME_ACTION)
+        return false
+    }
+
+    override fun onRotateLocked() {
+        userAction(MapUserAction.ONE_TIME_ACTION)
+    }
+
+    override fun onRotateEvent(p0: Float): Boolean {
+        userAction(MapUserAction.ONE_TIME_ACTION)
+        return false
+    }
+
+    override fun onTiltEvent(p0: Float): Boolean {
+        userAction(MapUserAction.ONE_TIME_ACTION)
+        return false
+    }
+
+    override fun onLongPressEvent(p0: PointF): Boolean {
+        userAction(MapUserAction.ONE_TIME_ACTION)
+        return false
+    }
+
+    override fun onLongPressRelease() {
+        userAction(MapUserAction.ONE_TIME_ACTION)
+    }
+
+    override fun onTwoFingerTapEvent(p0: PointF): Boolean {
+        userAction(MapUserAction.ONE_TIME_ACTION)
+        return false
+    }
+}
\ No newline at end of file
diff --git a/positioning/app/src/main/java/com/here/android/example/basicpositioningsolution/MapUserAction.kt b/positioning/app/src/main/java/com/here/android/example/basicpositioningsolution/MapUserAction.kt
new file mode 100644
index 00000000..c95e849b
--- /dev/null
+++ b/positioning/app/src/main/java/com/here/android/example/basicpositioningsolution/MapUserAction.kt
@@ -0,0 +1,7 @@
+package com.here.android.example.basicpositioningsolution
+
+enum class MapUserAction {
+    CONTINUOUS_ACTION_STARTED,
+    CONTINUOUS_ACTION_FINISHED,
+    ONE_TIME_ACTION
+}
\ No newline at end of file
diff --git a/positioning/app/src/main/java/com/here/android/example/basicpositioningsolution/MapViewModel.kt b/positioning/app/src/main/java/com/here/android/example/basicpositioningsolution/MapViewModel.kt
new file mode 100644
index 00000000..aca839ae
--- /dev/null
+++ b/positioning/app/src/main/java/com/here/android/example/basicpositioningsolution/MapViewModel.kt
@@ -0,0 +1,114 @@
+package com.here.android.example.basicpositioningsolution
+
+import android.util.Log
+import androidx.lifecycle.ViewModel
+import androidx.lifecycle.viewModelScope
+import com.here.android.mpa.mapping.Map
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.channels.BufferOverflow
+import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.flow.MutableSharedFlow
+import kotlinx.coroutines.flow.SharingStarted
+import kotlinx.coroutines.flow.collectLatest
+import kotlinx.coroutines.flow.combine
+import kotlinx.coroutines.flow.conflate
+import kotlinx.coroutines.flow.distinctUntilChanged
+import kotlinx.coroutines.flow.filterNotNull
+import kotlinx.coroutines.flow.flatMapLatest
+import kotlinx.coroutines.flow.flowOn
+import kotlinx.coroutines.flow.map
+import kotlinx.coroutines.flow.shareIn
+import kotlinx.coroutines.launch
+import kotlin.math.roundToInt
+
+class MapViewModel : ViewModel() {
+
+    private lateinit var arrowRotationCallback: (ArrowState) -> Unit
+    private var map: Map? = null
+    private val mapFlow: MutableSharedFlow<Map> =
+        MutableSharedFlow(replay = 1, onBufferOverflow = BufferOverflow.DROP_OLDEST)
+
+    private val userAction: MutableSharedFlow<MapUserAction> =
+        MutableSharedFlow(replay = 1, onBufferOverflow = BufferOverflow.DROP_OLDEST)
+
+    private val _heading: MutableSharedFlow<Double> =
+        MutableSharedFlow(replay = 1, onBufferOverflow = BufferOverflow.DROP_OLDEST)
+
+    private val heading: Flow<Float> by lazy {
+        _heading
+            .map { it.roundToInt().toFloat() }
+            .conflate()
+            .distinctUntilChanged()
+            .flowOn(Dispatchers.Default)
+            .shareIn(scope = viewModelScope, replay = 1, started = SharingStarted.WhileSubscribed())
+    }
+
+    private val hasUserAction by lazy {
+        userAction
+            .conflate()
+            .flowOn(Dispatchers.Default)
+            .shareIn(scope = viewModelScope, replay = 1, started = SharingStarted.WhileSubscribed())
+    }
+
+    private val mapTransformationFlow by lazy {
+        mapFlow.flatMapLatest { it.mapTransformationStateFlow }
+            .conflate()
+            .distinctUntilChanged()
+            .flowOn(Dispatchers.Default)
+            .shareIn(scope = viewModelScope, started = SharingStarted.WhileSubscribed(1000))
+    }
+    private val arrowState: Flow<ArrowState> by lazy {
+        combine(
+            hasUserAction,
+            heading,
+            mapTransformationFlow
+        ) { _isUserJustMadeActionTrigger, heading, mapTransformationTriggerEvent ->
+            if (map != null) {
+                Log.d(
+                    "ArrowState",
+                    "map != null, heading " + heading + "map!!.orientation " + map!!.orientation
+                )
+                val arrowRotationAngle = heading - map!!.orientation
+                ArrowState(
+                    arrowRotationAngle.roundToInt().toFloat(),
+                    mapTransformationTriggerEvent.mapState?.tilt ?: map!!.tilt
+                )
+            } else {
+                Log.d("ArrowState", "map == null")
+                null
+            }
+
+        }.filterNotNull()
+            .conflate()
+            .distinctUntilChanged()
+            .flowOn(Dispatchers.Default)
+            .shareIn(scope = viewModelScope, replay = 1, started = SharingStarted.WhileSubscribed())
+    }
+
+    init {
+        viewModelScope.launch(Dispatchers.Main) {
+            arrowState
+                .collectLatest {
+                    arrowRotationCallback?.invoke(it)
+                }
+        }
+    }
+
+    fun onUserAction(mapUserAction: MapUserAction) {
+        userAction.tryEmit(mapUserAction)
+    }
+
+    fun onHeading(heading: Double) {
+        _heading.tryEmit(heading)
+    }
+
+    fun addMap(map: Map) {
+        this.map = map
+        mapFlow.tryEmit(map)
+    }
+
+    fun setArrowCallback(callback: (ArrowState) -> Unit) {
+        this.arrowRotationCallback = callback
+    }
+
+}
\ No newline at end of file
diff --git a/positioning/app/src/main/res/drawable/ic_map_arrow.xml b/positioning/app/src/main/res/drawable/ic_map_arrow.xml
new file mode 100644
index 00000000..63990d70
--- /dev/null
+++ b/positioning/app/src/main/res/drawable/ic_map_arrow.xml
@@ -0,0 +1,12 @@
+<vector xmlns:android="http://schemas.android.com/apk/res/android"
+    android:width="64px"
+    android:height="64px"
+    android:viewportWidth="64"
+    android:viewportHeight="64">
+  <path
+      android:pathData="M32,32m-32,0a32,32 0,1 1,64 0a32,32 0,1 1,-64 0"
+      android:fillColor="#0F1011"/>
+  <path
+      android:pathData="M31.0698,13.628C31.4029,12.7907 32.5971,12.7907 32.9302,13.628L47,49L32,42.0533L17,49L31.0698,13.628Z"
+      android:fillColor="#EEEEEE"/>
+</vector>
diff --git a/positioning/build.gradle b/positioning/build.gradle
index ecdbfd77..755258a1 100644
--- a/positioning/build.gradle
+++ b/positioning/build.gradle
@@ -1,6 +1,7 @@
 // Top-level build file where you can add configuration options common to all sub-projects/modules.
 
 buildscript {
+    ext.kotlin_version = '1.6.20'
     repositories {
         google()
         jcenter()
@@ -8,6 +9,7 @@ buildscript {
 
     dependencies {
         classpath 'com.android.tools.build:gradle:7.2.2'
+        classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlin_version"
 
         // NOTE: Do not place your application dependencies here; they belong
         // in the individual module build.gradle files