class YourArFragment : ArFragment() {
    override fun onCreateView(inflater: LayoutInflater, container: ViewGroup?, savedInstanceState: Bundle?): View? {
        val view = super.onCreateView(inflater, container, savedInstanceState)

        // Turn off the plane discovery since we're only looking for ArImages
        planeDiscoveryController.hide()
        planeDiscoveryController.setInstructionView(null)
        arSceneView.planeRenderer.isEnabled = false

        // set touch event listener
        arSceneView.scene.setOnTouchListener(::onTouchEvent)

        // add frame update listener
        arSceneView.scene.addOnUpdateListener(::onUpdateFrame)

        return view
    }

    override fun getSessionConfiguration(session: Session): Config {
        val config = super.getSessionConfiguration(session)
        config.focusMode = Config.FocusMode.AUTO // make camera auto focus

        // load pre-build image database
        config.augmentedImageDatabase = AugmentedImageDatabase.deserialize(session, context!!.resources.assets.open("your.imgdb"))

        // or you can build image database real time
        // val db = AugmentedImageDatabase(session)
        // db.addImage("key", BitmapFactory.decodeStream( context!!.resources.assets.open("your.png")))
        // config.augmentedImageDatabase = db

        return config
    }

    private fun onUpdateFrame(frameTime: FrameTime?){
        // we will add anchor here later
    }

    private fun onTouchEvent(hitTestResult: HitTestResult, motionEvent: MotionEvent){
        // we will add touch event for swipe here later
    }
}

class YourArFragment : ArFragment() {
    companion object {
        // load model renderable
        val modelARendereable: CompletableFuture<ModelRenderable> = 
            ModelRenderable
                .builder()
                .setSource(context, Uri.parse("modelA.sfb"))
                .build()

        // load view 
        val viewARendereable: CompletableFuture<ViewRenderable> = 
            ViewRenderable
                .builder()
                .setView(context, R.layout.view_a)
                .build()
    }
}

class YourArFragment : ArFragment() {
    // to keep tracking which trackable that we have created AnchorNode with it or not.
    private val trackableMap = mutableMapOf<String, AnchorNode>()

    private fun onUpdateFrame(frameTime: FrameTime?){
        val frame = arSceneView.arFrame

        // If there is no frame or ARCore is not tracking yet, just return.
        if (frame == null || frame.camera.trackingState != TrackingState.TRACKING) {
            return
        }

        // get detected AugmentedImages
        // there are three types of trackables, they are AugmentedImage, Plane and Point.
        frame.getUpdatedTrackables(AugmentedImage::class.java).forEach { image ->
            when (image.trackingState) {
                // if it is in tracking state and we didn't add AnchorNode, then add one
                TrackingState.TRACKING -> if (!trackableMap.contains(image.name)) {
                    createAnchorNode(image)
                }
                TrackingState.STOPPED -> {
                    // remove it
                    trackableMap.remove(image.name)
                }
                else -> {
                }
            }
        }
    }

    private fun createAnchorNode(image: AugmentedImage) {
        val an = when (image.name) {
            "objectA" -> createObjectA(image)
        }

        if (an != null){
            // add the AnchorNode to the scene
            arSceneView.scene.addChild(node)

            // keep the node
            trackableMap[image.name] = an
        }
    }

    val objectAWidth: Float // the real width of model A
    val objectAHeight: Float // the real height of model A

    private fun createObjectA(image: AugmentedImage) : AnchorNode {
        val anchorNode = AnchorNode()
                
        // make anchor in the center of the images
        anchorNode.anchor = image.createAnchor(image.centerPose)
        
        var arWidth = image.extentX // extentX is estimated width
        var arHeight = image.extentZ // extentZ is estimated height

        var scaledSize = objectAWidth / arWidth

        // add model A
        val modelA = Node()

        // scale to the right size
        modelA.localScale = Vector3(scaledSize, scaledSize, scaledSize)

        // model is in the center of the image, change it if you want to put on other places
        var offsetToTop = -arHeight / 2
        var offsetToLeft = -arWidth / 2
        modelA.localPosition = Vector3(offsetToLeft, 0f, offsetToTop)

        // load the model
        modelARendereable.thenAccept {
            modelA.renderable = it
        }

        modelA.setParent(anchorNode)

        // add view A
        val viewA = Node()
        viewA.localScale = Vector3(scaledSize, scaledSize, scaledSize)

        // view is flat, so have to make it vertical.
        viewA.localRotation = Quaternion(Vector3(1f, 0f, 0f), -90f)

        // load the model
        viewARendereable.thenAccept {
            viewA.renderable = it
        }

        viewA.setParent(anchorNode)

        return anchorNode
    }
}

class YourArFragment : ArFragment() {
    private fun onTouchEvent(hitTestResult: HitTestResult, motionEvent: MotionEvent){
        swipeGestureDetector.onTouchEvent(motionEvent)
    }

    private val swipeGestureDetector = GestureDetector(null, object : GestureDetector.SimpleOnGestureListener() {
        private val SWIPE_DISTANCE_THRESHOLD = 100
        private val SWIPE_VELOCITY_THRESHOLD = 100

        override fun onDown(e: MotionEvent?): Boolean { return true }

        override fun onFling(e1: MotionEvent, e2: MotionEvent, velocityX: Float, velocityY: Float): Boolean {
            val distanceX = e2.x - e1.x
            val distanceY = e2.y - e1.y
            if (Math.abs(distanceX) > Math.abs(distanceY) && Math.abs(distanceX) > SWIPE_DISTANCE_THRESHOLD && Math.abs(velocityX) > SWIPE_VELOCITY_THRESHOLD) {
                if (distanceX > 0) {
                    // do some thing for swiping left to right
                } else {
                    // do some thing for swiping right to left
                }

                return true
            }

            return false
        }
    })
}

class YourArFragment : ArFragment() {
    private fun createObjectA(image: AugmentedImage) : AnchorNode {
        ...
        // just change Node to TransformableNode
        // TransformableNode will handle drag, pinch and twist gestures
        // if you want to handle by your self you can use BaseTransformableNode
        val modelA = TransformableNode(transformationSystem)
        ...
    }
}

val orientation1 = Quaternion.axisAngle(Vector3(0.0f, 0.0f, 1.0f), 0f)
val orientation2 = Quaternion.axisAngle(Vector3(0.0f, 0.0f, 1.0f), 120f)
val orientation3 = Quaternion.axisAngle(Vector3(0.0f, 0.0f, 1.0f), 240f)
val orientation4 = Quaternion.axisAngle(Vector3(0.0f, 0.0f, 1.0f), 360f)

val animation = ObjectAnimator()
animation.setObjectValues(orientation1, orientation2, orientation3, orientation4)
animation.propertyName = "localRotation"
animation.setEvaluator(QuaternionEvaluator())
animation.repeatCount = ObjectAnimator.INFINITE
animation.repeatMode = ObjectAnimator.RESTART
animation.interpolator = LinearInterpolator()
animation.setAutoCancel(true)
animation.duration = 1000
animation.target = modelA
animation.start()

val texture = ExternalTexture()
val videoPlayer = MediaPlayer.create(context, R.raw.video)
videoPlayer.setSurface(texture.surface)
videoPlayer.isLooping = true

// We use ARCore's Model and it has defined viewTexture parameter in its material
val videoRenderable = ModelRenderable.builder()
                                     .setSource(context, com.google.ar.sceneform.rendering.R.raw.sceneform_view_renderable)
                                     .build()
            

videoRenderable.thenAccept { renderable ->
    renderable.material.setExternalTexture("viewTexture", texture)

    videoNode.renderable = renderable
    videoPlayer.start()
}