package com.here.hellomapandroidauto;

import android.content.Intent;
import android.content.pm.ApplicationInfo;

import androidx.annotation.NonNull;
import androidx.annotation.Nullable;
import androidx.car.app.CarAppService;
import androidx.car.app.Screen;
import androidx.car.app.Session;
import androidx.car.app.validation.HostValidator;

/**
 * Entry point for the hello map app.
 *
 * <p>{@link CarAppService} is the main interface between the app and the car host. For more
 * details, see the <a href="https://developer.android.com/training/cars/apps">Android for
 * Cars Library developer guide</a>.
 */
public final class HelloMapCarAppService extends CarAppService {

    public HelloMapCarAppService() {
        // Exported services must have an empty public constructor.
    }

    @Override
    @NonNull
    public Session onCreateSession() {
        return new Session() {
            @Override
            @NonNull
            public Screen onCreateScreen(@Nullable Intent intent) {

                // Ensure the HERE SDK is initialized (if it is not already initialized
                // via MainActivity).
                HereSDKInitializer.run(HelloMapCarAppService.this);

                return new HelloMapScreen(getCarContext());
            }
        };
    }

    @NonNull
    @Override
    public HostValidator createHostValidator() {
        if ((getApplicationInfo().flags & ApplicationInfo.FLAG_DEBUGGABLE) != 0) {
            return HostValidator.ALLOW_ALL_HOSTS_VALIDATOR;
        } else {
            return new HostValidator.Builder(getApplicationContext())
                    .addAllowedHosts(androidx.car.app.R.array.hosts_allowlist_sample)
                    .build();
        }
    }
}

package com.here.hellomapandroidautokotlin

import android.content.Intent
import android.content.pm.ApplicationInfo
import androidx.car.app.CarAppService
import androidx.car.app.R
import androidx.car.app.Screen
import androidx.car.app.Session
import androidx.car.app.validation.HostValidator
import androidx.lifecycle.DefaultLifecycleObserver
import androidx.lifecycle.LifecycleOwner

/**
 * Entry point for Android Auto - when connected to a DHU or an in-car head unit.
 *
 *
 * [CarAppService] is the main interface between the app and the car host. For more
 * details, see the [Android for Cars Library developer guide](https://developer.android.com/training/cars/navigation).
 */
class HelloMapCarAppService : CarAppService() {
    override fun onCreateSession(): Session {
        val session: Session = object : Session() {
            override fun onCreateScreen(intent: Intent): Screen {
                return HelloMapScreen(carContext)
            }
        }

        session.lifecycle.addObserver(object : DefaultLifecycleObserver {
            override fun onCreate(owner: LifecycleOwner) {
                HERESDKLifecycle.start(this@HelloMapCarAppService)
            }

            override fun onDestroy(owner: LifecycleOwner) {
                HERESDKLifecycle.stop()
            }
        })

        return session
    }

    override fun createHostValidator(): HostValidator {
        return if ((applicationInfo.flags and ApplicationInfo.FLAG_DEBUGGABLE) != 0) {
            HostValidator.ALLOW_ALL_HOSTS_VALIDATOR
        } else {
            HostValidator.Builder(applicationContext)
                .addAllowedHosts(R.array.hosts_allowlist_sample)
                .build()
        }
    }
}

package com.here.hellomapandroidauto;

import android.util.Log;

import androidx.annotation.NonNull;
import androidx.annotation.Nullable;
import androidx.car.app.AppManager;
import androidx.car.app.CarContext;
import androidx.car.app.Screen;
import androidx.car.app.SurfaceCallback;
import androidx.car.app.SurfaceContainer;
import androidx.car.app.model.Action;
import androidx.car.app.model.ActionStrip;
import androidx.car.app.model.CarIcon;
import androidx.car.app.model.Template;
import androidx.car.app.navigation.model.NavigationTemplate;
import androidx.core.graphics.drawable.IconCompat;

import com.here.sdk.core.GeoCoordinates;
import com.here.sdk.core.Point2D;
import com.here.sdk.core.Size2D;
import com.here.sdk.mapview.MapError;
import com.here.sdk.mapview.MapMeasure;
import com.here.sdk.mapview.MapScene;
import com.here.sdk.mapview.MapScheme;
import com.here.sdk.mapview.MapSurface;

/**
 * A screen that shows a HERE SDK map view.
 *
 * <p>See {@link HelloMapCarAppService} for the app's entry point to the car host.
 */
public class HelloMapScreen extends Screen implements SurfaceCallback {

    private MapSurface mapSurface;
    private CarContext carContext;

    public HelloMapScreen(@NonNull CarContext carContext) {
        super(carContext);
        this.carContext = carContext;

        Log.d("HelloMapScreen", "Register surface callback");
        carContext.getCarService(AppManager.class).setSurfaceCallback(this);

        // Since the MapSurface implements MapViewBase, it behaves like a MapView, except that it
        // renders on the DHU running Android Auto.
        mapSurface = new MapSurface();
    }

    @NonNull
    @Override
    public Template onGetTemplate() {
        CarIcon zoomInIcon = new CarIcon.Builder(
                IconCompat.createWithResource(carContext, R.drawable.plus)).build();
        CarIcon zoomOutIcon = new CarIcon.Builder(
                IconCompat.createWithResource(carContext, R.drawable.minus)).build();

        // Add buttons to zoom in/out the map view and to exit the app.
        ActionStrip.Builder actionStripBuilder = new ActionStrip.Builder();
        actionStripBuilder.addAction(
                new Action.Builder()
                        .setIcon(zoomInIcon)
                        .setOnClickListener(this::zoomIn)
                        .build());
        actionStripBuilder.addAction(
                new Action.Builder()
                        .setIcon(zoomOutIcon)
                        .setOnClickListener(this::zoomOut)
                        .build());
        actionStripBuilder.addAction(
                new Action.Builder()
                        .setTitle("Exit")
                        .setOnClickListener(this::exit)
                        .build());

        NavigationTemplate.Builder builder = new NavigationTemplate.Builder();
        builder.setActionStrip(actionStripBuilder.build());
        return builder.build();
    }

    @Override
    public void onSurfaceAvailable(@NonNull SurfaceContainer surfaceContainer) {
        Log.d("HelloMapScreen", "Received a surface.");
        mapSurface.attachSurface(
                carContext,
                surfaceContainer.getSurface(),
                surfaceContainer.getWidth(),
                surfaceContainer.getHeight());

        mapSurface.getMapScene().loadScene(MapScheme.NORMAL_DAY, new MapScene.LoadSceneCallback() {
            @Override
            public void onLoadScene(@Nullable MapError mapError) {
                if (mapError == null) {
                    double distanceInMeters = 1000 * 10;
                    MapMeasure mapMeasureZoom = new MapMeasure(MapMeasure.Kind.DISTANCE_IN_METERS, distanceInMeters);
                    mapSurface.getCamera().lookAt(new GeoCoordinates(52.530932, 13.384915), mapMeasureZoom);
                } else {
                    Log.d("HelloMapScreen", "Loading map failed: mapError: " + mapError.name());
                }
            }
        });
    }

    @Override
    public void onSurfaceDestroyed(@NonNull SurfaceContainer surfaceContainer) {
        mapSurface.destroySurface();
    }

    private void zoomIn() {
        double zoomFactor = 2;
        mapSurface.getCamera().zoomBy(zoomFactor, getCenterPoint());
    }

    private void zoomOut() {
        double zoomFactor = 0.5;
        mapSurface.getCamera().zoomBy(zoomFactor, getCenterPoint());
    }

    private void exit() {
        carContext.finishCarApp();
    }

    private Point2D getCenterPoint() {
        Size2D viewport = mapSurface.getViewportSize();
        return new Point2D(viewport.width * 0.5, viewport.height * 0.5);
    }
}

package com.here.hellomapandroidautokotlin

import android.util.Log
import androidx.car.app.AppManager
import androidx.car.app.CarContext
import androidx.car.app.Screen
import androidx.car.app.SurfaceCallback
import androidx.car.app.SurfaceContainer
import androidx.car.app.model.Action
import androidx.car.app.model.ActionStrip
import androidx.car.app.model.CarIcon
import androidx.car.app.model.Template
import androidx.car.app.navigation.model.NavigationTemplate
import androidx.core.graphics.drawable.IconCompat
import com.here.sdk.core.GeoCoordinates
import com.here.sdk.core.Point2D
import com.here.sdk.mapview.MapMeasure
import com.here.sdk.mapview.MapScheme
import com.here.sdk.mapview.MapSurface

/**
 * A screen that shows a HERE SDK map view - when connected to a DHU or an in-car head unit.
 *
 *
 * See [HelloMapCarAppService] for the app's entry point to the car host.
 */
class HelloMapScreen(private val carContext: CarContext) : Screen(carContext), SurfaceCallback {
    private val mapSurface: MapSurface

    init {
        Log.d(TAG, "Register surface callback")
        carContext.getCarService(AppManager::class.java).setSurfaceCallback(this)

        // Since the MapSurface implements MapViewBase, it behaves like a MapView, except that it
        // renders on the DHU running Android Auto.
        mapSurface = MapSurface()
    }

    override fun onGetTemplate(): Template {
        val zoomInIcon = CarIcon.Builder(
            IconCompat.createWithResource(carContext, R.drawable.plus)
        ).build()
        val zoomOutIcon = CarIcon.Builder(
            IconCompat.createWithResource(carContext, R.drawable.minus)
        ).build()

        // Add buttons to zoom in/out the map view and to exit the app.
        val actionStripBuilder = ActionStrip.Builder()
        actionStripBuilder.addAction(
            Action.Builder()
                .setIcon(zoomInIcon)
                .setOnClickListener { this.zoomIn() }
                .build())
        actionStripBuilder.addAction(
            Action.Builder()
                .setIcon(zoomOutIcon)
                .setOnClickListener { this.zoomOut() }
                .build())
        actionStripBuilder.addAction(
            Action.Builder()
                .setTitle("Exit")
                .setOnClickListener { this.exit() }
                .build())

        val builder = NavigationTemplate.Builder()
        builder.setActionStrip(actionStripBuilder.build())

        builder.setMapActionStrip(
            ActionStrip.Builder()
                .addAction( // Must be present (even on a car with touch screen) to enable PAN mode. PAN
                    // mode is required to enable reception of gestures.
                    Action.Builder(Action.PAN).build()
                ).build()
        )

        return builder.build()
    }

    override fun onSurfaceAvailable(surfaceContainer: SurfaceContainer) {
        Log.d(TAG, "Received a surface.")

        mapSurface.attachSurface(
            carContext,
            surfaceContainer.surface,
            surfaceContainer.width,
            surfaceContainer.height
        )

        mapSurface.mapScene.loadScene(
            MapScheme.NORMAL_DAY
        ) { mapError ->
            mapError?.let {
                Log.d(TAG, "Loading map failed: mapError: ${mapError.name}")
                return@loadScene
            }
            val distanceInMeters = (1000 * 10).toDouble()
            val mapMeasureZoom =
                MapMeasure(MapMeasure.Kind.DISTANCE_IN_METERS, distanceInMeters)
            mapSurface.camera.lookAt(GeoCoordinates(52.530932, 13.384915), mapMeasureZoom)
        }
    }

    override fun onSurfaceDestroyed(surfaceContainer: SurfaceContainer) {
        mapSurface.destroySurface()
    }

    private fun zoomIn() {
        val zoomFactor = 2.0
        mapSurface.camera.zoomBy(zoomFactor, centerPoint)
    }

    private fun zoomOut() {
        val zoomFactor = 0.5
        mapSurface.camera.zoomBy(zoomFactor, centerPoint)
    }

    private fun exit() {
        carContext.finishCarApp()
    }

    private val centerPoint: Point2D
        get() {
            val viewport = mapSurface.viewportSize
            return Point2D(viewport.width * 0.5, viewport.height * 0.5)
        }

    /**
     * Will be called on scroll event. Needs car api version 2 to work.
     * See [SurfaceCallback.onScroll] definition for more details.
     */
    override fun onScroll(distanceX: Float, distanceY: Float) {
        mapSurface.gestures.scrollHandler.onScroll(distanceX, distanceY)
    }

    /**
     * Will be called on scale event. Needs car api version 2 to work.
     * See [SurfaceCallback.onScale] definition for more details.
     */
    override fun onScale(focusX: Float, focusY: Float, scaleFactor: Float) {
        mapSurface.gestures.scaleHandler.onScale(focusX, focusY, scaleFactor)
    }

    /**
     * Will be called on scale event. Needs car api version 2 to work.
     * See [SurfaceCallback.onFling] definition for more details.
     */
    override fun onFling(velocityX: Float, velocityY: Float) {
        /**
         *
         * Fling event appears to have inverted axis compared to scroll event on desktop head unit.
         * This should not be the case according to
         * [androidx.car.app.navigation.model.NavigationTemplate]. To compensate inverted axis
         * , factor of -1 was introduced. This might differ depending on which head unit model is
         * used.
         */
        mapSurface.gestures.flingHandler.onFling(-1 * velocityX, -1 * velocityY)
    }

    companion object {
        private val TAG: String = HelloMapScreen::class.java.simpleName
    }
}

mapSurface.attachSurface(
        carContext,
        surfaceContainer.getSurface(),
        surfaceContainer.getWidth(),
        surfaceContainer.getHeight());

mapSurface.attachSurface(
    carContext,
    surfaceContainer.surface,
    surfaceContainer.width,
    surfaceContainer.height
)

double zoomFactor = 2;
mapSurface.getCamera().zoomBy(zoomFactor, getCenterPoint());

val zoomFactor = 2.0
mapSurface.camera.zoomBy(zoomFactor, centerPoint)