diff --git a/authfs/tests/common/src/open_then_run.rs b/authfs/tests/common/src/open_then_run.rs
index a976784..e5e33eb 100644
--- a/authfs/tests/common/src/open_then_run.rs
+++ b/authfs/tests/common/src/open_then_run.rs
@@ -118,6 +118,7 @@
                 .read(true)
                 .write(true)
                 .create(true)
+                .truncate(true)
                 .open(path)
                 .with_context(|| format!("Open {} read-write", path))?,
         ))
diff --git a/libs/android_display_backend/Android.bp b/libs/android_display_backend/Android.bp
new file mode 100644
index 0000000..6ad5fab
--- /dev/null
+++ b/libs/android_display_backend/Android.bp
@@ -0,0 +1,55 @@
+aidl_interface {
+    name: "libcrosvm_android_display_service",
+    srcs: [
+        "aidl/android/crosvm/ICrosvmAndroidDisplayService.aidl",
+    ],
+    include_dirs: [
+        "frameworks/native/aidl/gui",
+    ],
+    local_include_dir: "aidl",
+    unstable: true,
+    backend: {
+        java: {
+            enabled: true,
+        },
+        cpp: {
+            enabled: false,
+        },
+        rust: {
+            enabled: false,
+        },
+        ndk: {
+            enabled: true,
+            // To use Surface
+            additional_shared_libraries: [
+                "libnativewindow",
+            ],
+            apex_available: [
+                "//apex_available:platform",
+                "com.android.virt",
+            ],
+        },
+    },
+}
+
+cc_library_static {
+    name: "libcrosvm_android_display_client",
+    srcs: [
+        "crosvm_android_display_client.cpp",
+    ],
+    whole_static_libs: [
+        "libcrosvm_android_display_service-ndk",
+        "android.system.virtualizationservice_internal-ndk",
+        "android.system.virtualizationcommon-ndk",
+        "android.system.virtualizationservice-ndk",
+        "libyuv",
+    ],
+    shared_libs: [
+        "libbinder_ndk",
+        "libnativewindow",
+    ],
+    apex_available: [
+        "//apex_available:platform",
+        "com.android.virt",
+    ],
+}
diff --git a/libs/android_display_backend/aidl/android/crosvm/ICrosvmAndroidDisplayService.aidl b/libs/android_display_backend/aidl/android/crosvm/ICrosvmAndroidDisplayService.aidl
new file mode 100644
index 0000000..c7bfc80
--- /dev/null
+++ b/libs/android_display_backend/aidl/android/crosvm/ICrosvmAndroidDisplayService.aidl
@@ -0,0 +1,29 @@
+/*
+ * Copyright 2024 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.crosvm;
+
+import android.view.Surface;
+
+/**
+ * Service to provide Crosvm with an Android Surface for showing a guest's
+ * display.
+ */
+interface ICrosvmAndroidDisplayService {
+    void setSurface(inout Surface surface);
+
+    void removeSurface();
+}
diff --git a/libs/android_display_backend/crosvm_android_display_client.cpp b/libs/android_display_backend/crosvm_android_display_client.cpp
new file mode 100644
index 0000000..a16b7f2
--- /dev/null
+++ b/libs/android_display_backend/crosvm_android_display_client.cpp
@@ -0,0 +1,286 @@
+/*
+ * Copyright 2024 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <aidl/android/crosvm/BnCrosvmAndroidDisplayService.h>
+#include <aidl/android/system/virtualizationservice_internal/IVirtualizationServiceInternal.h>
+#include <android/binder_manager.h>
+#include <android/binder_process.h>
+#include <android/native_window.h>
+#include <android/native_window_aidl.h>
+#include <libyuv.h>
+#include <stdint.h>
+#include <utils/Errors.h>
+
+#include <condition_variable>
+#include <memory>
+#include <mutex>
+#include <vector>
+
+using aidl::android::system::virtualizationservice_internal::IVirtualizationServiceInternal;
+
+#define LIBEXPORT __attribute__((visibility("default"))) extern "C"
+
+typedef void (*android_display_log_callback_type)(const char* message);
+
+static void android_display_log_callback_stub(const char* message) {
+    (void)message;
+}
+
+namespace {
+
+class DisplayService : public aidl::android::crosvm::BnCrosvmAndroidDisplayService {
+public:
+    DisplayService() = default;
+    virtual ~DisplayService() = default;
+
+    ndk::ScopedAStatus setSurface(aidl::android::view::Surface* surface) override {
+        {
+            std::lock_guard lk(mSurfaceReadyMutex);
+            mSurface = std::make_unique<aidl::android::view::Surface>(surface->release());
+        }
+        mSurfaceReady.notify_one();
+        return ::ndk::ScopedAStatus::ok();
+    }
+
+    ndk::ScopedAStatus removeSurface() override {
+        {
+            std::lock_guard lk(mSurfaceReadyMutex);
+            mSurface = nullptr;
+        }
+        mSurfaceReady.notify_one();
+        return ::ndk::ScopedAStatus::ok();
+    }
+
+    aidl::android::view::Surface* getSurface() {
+        std::unique_lock lk(mSurfaceReadyMutex);
+        mSurfaceReady.wait(lk, [this] { return mSurface != nullptr; });
+        return mSurface.get();
+    }
+
+private:
+    std::condition_variable mSurfaceReady;
+    std::mutex mSurfaceReadyMutex;
+    std::unique_ptr<aidl::android::view::Surface> mSurface;
+};
+
+void ErrorF(android_display_log_callback_type error_callback, const char* format, ...) {
+    char buffer[1024];
+
+    va_list vararg;
+    va_start(vararg, format);
+    vsnprintf(buffer, sizeof(buffer), format, vararg);
+    va_end(vararg);
+
+    error_callback(buffer);
+}
+
+} // namespace
+
+struct android_display_context {
+    uint32_t width;
+    uint32_t height;
+    std::shared_ptr<DisplayService> displayService;
+};
+
+LIBEXPORT
+struct android_display_context* create_android_display_context(
+        const char* name, size_t name_len, android_display_log_callback_type error_callback) {
+    auto ctx = new android_display_context();
+
+    auto service = ::ndk::SharedRefBase::make<DisplayService>();
+
+    if (strlen(name) != name_len) {
+        ErrorF(error_callback, "Invalid service name length. Expected %u, actual %u", name_len,
+               strlen(name));
+        return nullptr;
+    }
+    ::ndk::SpAIBinder binder(
+            AServiceManager_waitForService("android.system.virtualizationservice"));
+
+    auto virt_service = IVirtualizationServiceInternal::fromBinder(binder);
+    if (virt_service == nullptr) {
+        ErrorF(error_callback, "Failed to find android.system.virtualizationservice");
+        return nullptr;
+    }
+    auto status = virt_service->setDisplayService(service->asBinder());
+    if (!status.isOk()) {
+        ErrorF(error_callback, "Failed to register %s",
+               aidl::android::crosvm::ICrosvmAndroidDisplayService::descriptor);
+        return nullptr;
+    }
+
+    ABinderProcess_startThreadPool();
+
+    auto surface = service->getSurface();
+    ctx->width = static_cast<uint32_t>(ANativeWindow_getWidth(surface->get()));
+    ctx->height = static_cast<uint32_t>(ANativeWindow_getHeight(surface->get()));
+    ctx->displayService = service;
+    return ctx;
+}
+
+LIBEXPORT
+void destroy_android_display_context(android_display_log_callback_type error_callback,
+                                     struct android_display_context* ctx) {
+    auto service = ::ndk::SharedRefBase::make<DisplayService>();
+    ::ndk::SpAIBinder binder(
+            AServiceManager_waitForService("android.system.virtualizationservice"));
+    auto virt_service = IVirtualizationServiceInternal::fromBinder(binder);
+    if (virt_service != nullptr) {
+        auto status = virt_service->clearDisplayService();
+    } else {
+        ErrorF(error_callback, "Failed to find android.system.virtualizationservice");
+    }
+
+    if (!ctx) {
+        ErrorF(error_callback, "Invalid context.");
+        return;
+    }
+
+    delete ctx;
+}
+
+LIBEXPORT
+uint32_t get_android_display_width(android_display_log_callback_type error_callback,
+                                   struct android_display_context* ctx) {
+    if (!ctx) {
+        ErrorF(error_callback, "Invalid context.");
+        return -1;
+    }
+    if (!ctx->displayService->getSurface()) {
+        ErrorF(error_callback, "Invalid context surface for ctx:%p.", ctx);
+        return -1;
+    }
+    return ctx->width;
+}
+
+LIBEXPORT
+uint32_t get_android_display_height(android_display_log_callback_type error_callback,
+                                    struct android_display_context* ctx) {
+    if (!ctx) {
+        ErrorF(error_callback, "Invalid context.");
+        return -1;
+    }
+    if (!ctx->displayService->getSurface()) {
+        ErrorF(error_callback, "Invalid context surface for ctx:%p.", ctx);
+        return -1;
+    }
+    return ctx->height;
+}
+
+uint16_t RGBA8888ToRGB565(uint8_t r, uint8_t g, uint8_t b, uint8_t a) {
+    (void)a;
+    return (static_cast<uint16_t>(r >> 3) << 11) | (static_cast<uint16_t>(g >> 2) << 5) |
+            (static_cast<uint16_t>(b >> 3) << 0);
+}
+
+LIBEXPORT
+void blit_android_display(android_display_log_callback_type error_callback,
+                          struct android_display_context* ctx, uint32_t width, uint32_t height,
+                          uint8_t* pixels, size_t pixels_num_bytes) {
+    if (!ctx) {
+        ErrorF(error_callback, "Invalid context.");
+        return;
+    }
+    if (!ctx->displayService->getSurface()) {
+        ErrorF(error_callback, "Invalid context surface.");
+        return;
+    }
+    if (pixels_num_bytes != width * height * 4) {
+        ErrorF(error_callback, "Invalid buffer size.");
+        return;
+    }
+    ANativeWindow* anw = ctx->displayService->getSurface()->get();
+    if (!anw) {
+        ErrorF(error_callback, "Invalid context surface.");
+        return;
+    }
+
+    ANativeWindow_Buffer anwBuffer = {};
+    if (ANativeWindow_lock(anw, &anwBuffer, nullptr) != android::OK) {
+        ErrorF(error_callback, "Failed to lock ANativeWindow.");
+        return;
+    }
+
+    // Source is always BGRA8888.
+    auto* src = reinterpret_cast<uint32_t*>(pixels);
+    auto srcWidth = static_cast<uint32_t>(width);
+    auto srcHeight = static_cast<uint32_t>(height);
+    auto srcStrideBytes = srcWidth * 4;
+    auto srcStridePixels = srcWidth;
+
+    auto dstWidth = static_cast<uint32_t>(anwBuffer.width);
+    auto dstHeight = static_cast<uint32_t>(anwBuffer.height);
+
+    // Scale to fit if needed.
+    std::vector<uint32_t> scaledSrc;
+    if (srcWidth != dstWidth || srcHeight != dstHeight) {
+        const float ratioWidth = static_cast<float>(dstWidth) / static_cast<float>(srcWidth);
+        const float ratioHeight = static_cast<float>(dstHeight) / static_cast<float>(srcHeight);
+        const float ratioUsed = std::min(ratioWidth, ratioHeight);
+
+        uint32_t scaledSrcWidth = static_cast<uint32_t>(static_cast<float>(srcWidth) * ratioUsed);
+        uint32_t scaledSrcHeight = static_cast<uint32_t>(static_cast<float>(srcHeight) * ratioUsed);
+        uint32_t scaledSrcStrideBytes = scaledSrcWidth * 4;
+        uint32_t scaledSrcStridePixels = scaledSrcWidth;
+
+        scaledSrc.resize(scaledSrcHeight * scaledSrcStridePixels);
+
+        libyuv::ARGBScale(reinterpret_cast<uint8_t*>(src), srcStrideBytes, srcWidth, srcHeight,
+                          reinterpret_cast<uint8_t*>(scaledSrc.data()), scaledSrcStrideBytes,
+                          scaledSrcWidth, scaledSrcHeight, libyuv::kFilterBilinear);
+
+        src = scaledSrc.data();
+        srcWidth = scaledSrcWidth;
+        srcHeight = scaledSrcHeight;
+        srcStrideBytes = scaledSrcStrideBytes;
+        srcStridePixels = scaledSrcStridePixels;
+    }
+
+    if (anwBuffer.format == AHARDWAREBUFFER_FORMAT_R8G8B8A8_UNORM) {
+        auto* dst = reinterpret_cast<uint32_t*>(anwBuffer.bits);
+        auto dstStridePixels = static_cast<uint32_t>(anwBuffer.stride);
+
+        for (uint32_t h = 0; h < std::min(srcHeight, dstHeight); h++) {
+            for (uint32_t w = 0; w < std::min(srcWidth, dstWidth); w++) {
+                dst[(h * dstStridePixels) + w] = src[(h * srcStridePixels) + w];
+            }
+        }
+    } else if (anwBuffer.format == AHARDWAREBUFFER_FORMAT_R5G6B5_UNORM) {
+        auto* dst = reinterpret_cast<uint16_t*>(anwBuffer.bits);
+        auto dstWidth = static_cast<uint32_t>(anwBuffer.width);
+        auto dstHeight = static_cast<uint32_t>(anwBuffer.height);
+        auto dstStridePixels = static_cast<uint32_t>(anwBuffer.stride);
+
+        for (uint32_t h = 0; h < std::min(srcHeight, dstHeight); h++) {
+            for (uint32_t w = 0; w < std::min(srcWidth, dstWidth); w++) {
+                uint32_t srcPixel = src[(h * srcStridePixels) + w];
+                uint8_t* srcPixelBytes = reinterpret_cast<uint8_t*>(&srcPixel);
+                uint8_t r = srcPixelBytes[2];
+                uint8_t g = srcPixelBytes[1];
+                uint8_t b = srcPixelBytes[0];
+                uint8_t a = srcPixelBytes[3];
+                dst[(h * dstStridePixels) + w] = RGBA8888ToRGB565(r, g, b, a);
+            }
+        }
+    } else {
+        ErrorF(error_callback, "Unhandled format: %d", anwBuffer.format);
+    }
+
+    if (ANativeWindow_unlockAndPost(anw) != android::OK) {
+        ErrorF(error_callback, "Failed to unlock and post ANativeWindow.");
+        return;
+    }
+}
diff --git a/libs/android_display_backend/crosvm_android_display_client.h b/libs/android_display_backend/crosvm_android_display_client.h
new file mode 100644
index 0000000..75b845b
--- /dev/null
+++ b/libs/android_display_backend/crosvm_android_display_client.h
@@ -0,0 +1,36 @@
+/*
+ * Copyright 2024 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+extern "C" {
+
+typedef void (*android_display_log_callback_type)(const char* message);
+
+static void android_display_log_callback_stub(const char* message) {
+    (void)message;
+}
+
+struct android_display_context {
+    uint32_t test;
+};
+
+__attribute__((visibility("default"))) struct android_display_context*
+create_android_display_context(const char* name, size_t name_len,
+                               android_display_log_callback_type error_callback);
+
+__attribute__((visibility("default"))) void destroy_android_display_context(
+        android_display_log_callback_type error_callback, struct android_display_context* ctx);
+
+} // extern C
diff --git a/virtualizationservice/aidl/Android.bp b/virtualizationservice/aidl/Android.bp
index 112e1cc..c479691 100644
--- a/virtualizationservice/aidl/Android.bp
+++ b/virtualizationservice/aidl/Android.bp
@@ -12,7 +12,10 @@
     backend: {
         java: {
             sdk_version: "module_current",
-            apex_available: ["com.android.virt"],
+            apex_available: [
+                "//apex_available:platform",
+                "com.android.virt",
+            ],
         },
         cpp: {
             enabled: true,
@@ -44,6 +47,9 @@
     backend: {
         java: {
             sdk_version: "module_current",
+            apex_available: [
+                "//apex_available:platform",
+            ],
         },
         rust: {
             enabled: true,
@@ -51,6 +57,11 @@
                 "com.android.virt",
             ],
         },
+        ndk: {
+            apex_available: [
+                "com.android.virt",
+            ],
+        },
     },
 }
 
@@ -103,7 +114,10 @@
     backend: {
         java: {
             sdk_version: "module_current",
-            apex_available: ["com.android.virt"],
+            apex_available: [
+                "com.android.virt",
+                "//apex_available:platform",
+            ],
         },
         ndk: {
             apex_available: [
diff --git a/virtualizationservice/aidl/android/system/virtualizationservice_internal/IVirtualizationServiceInternal.aidl b/virtualizationservice/aidl/android/system/virtualizationservice_internal/IVirtualizationServiceInternal.aidl
index 16975ee..84f8734 100644
--- a/virtualizationservice/aidl/android/system/virtualizationservice_internal/IVirtualizationServiceInternal.aidl
+++ b/virtualizationservice/aidl/android/system/virtualizationservice_internal/IVirtualizationServiceInternal.aidl
@@ -116,4 +116,9 @@
      * @param instanceId The ID for the VM.
      */
     void claimVmInstance(in byte[64] instanceId);
+
+    // TODO(b/330257000): Remove these functions when a display service is running with binder RPC.
+    void setDisplayService(IBinder ibinder);
+    void clearDisplayService();
+    IBinder waitDisplayService();
 }
diff --git a/virtualizationservice/src/aidl.rs b/virtualizationservice/src/aidl.rs
index c6150b2..1fa634d 100644
--- a/virtualizationservice/src/aidl.rs
+++ b/virtualizationservice/src/aidl.rs
@@ -51,7 +51,7 @@
 use std::os::unix::fs::PermissionsExt;
 use std::os::unix::raw::{pid_t, uid_t};
 use std::path::{Path, PathBuf};
-use std::sync::{Arc, Mutex, Weak};
+use std::sync::{Arc, Condvar, Mutex, Weak};
 use tombstoned_client::{DebuggerdDumpType, TombstonedConnection};
 use virtualizationcommon::Certificate::Certificate;
 use virtualizationmaintenance::{
@@ -170,12 +170,15 @@
 #[derive(Clone)]
 pub struct VirtualizationServiceInternal {
     state: Arc<Mutex<GlobalState>>,
+    display_service_set: Arc<Condvar>,
 }
 
 impl VirtualizationServiceInternal {
     pub fn init() -> VirtualizationServiceInternal {
-        let service =
-            VirtualizationServiceInternal { state: Arc::new(Mutex::new(GlobalState::new())) };
+        let service = VirtualizationServiceInternal {
+            state: Arc::new(Mutex::new(GlobalState::new())),
+            display_service_set: Arc::new(Condvar::new()),
+        };
 
         std::thread::spawn(|| {
             if let Err(e) = handle_stream_connection_tombstoned() {
@@ -190,6 +193,39 @@
 impl Interface for VirtualizationServiceInternal {}
 
 impl IVirtualizationServiceInternal for VirtualizationServiceInternal {
+    fn setDisplayService(
+        &self,
+        ibinder: &binder::SpIBinder,
+    ) -> std::result::Result<(), binder::Status> {
+        check_manage_access()?;
+        check_use_custom_virtual_machine()?;
+        let state = &mut *self.state.lock().unwrap();
+        state.display_service = Some(ibinder.clone());
+        self.display_service_set.notify_all();
+        Ok(())
+    }
+
+    fn clearDisplayService(&self) -> std::result::Result<(), binder::Status> {
+        check_manage_access()?;
+        check_use_custom_virtual_machine()?;
+        let state = &mut *self.state.lock().unwrap();
+        state.display_service = None;
+        self.display_service_set.notify_all();
+        Ok(())
+    }
+
+    fn waitDisplayService(&self) -> std::result::Result<binder::SpIBinder, binder::Status> {
+        check_manage_access()?;
+        check_use_custom_virtual_machine()?;
+        let state = self
+            .display_service_set
+            .wait_while(self.state.lock().unwrap(), |state| state.display_service.is_none())
+            .unwrap();
+        Ok((state.display_service)
+            .as_ref()
+            .cloned()
+            .expect("Display service cannot be None in this context"))
+    }
     fn removeMemlockRlimit(&self) -> binder::Result<()> {
         let pid = get_calling_pid();
         let lim = libc::rlimit { rlim_cur: libc::RLIM_INFINITY, rlim_max: libc::RLIM_INFINITY };
@@ -588,6 +624,8 @@
 
     /// State relating to secrets held by (optional) Secretkeeper instance on behalf of VMs.
     sk_state: Option<maintenance::State>,
+
+    display_service: Option<binder::SpIBinder>,
 }
 
 impl GlobalState {
@@ -596,6 +634,7 @@
             held_contexts: HashMap::new(),
             dtbo_file: Mutex::new(None),
             sk_state: maintenance::State::new(),
+            display_service: None,
         }
     }
 
diff --git a/vmlauncher_app/Android.bp b/vmlauncher_app/Android.bp
index cd40448..06dcf7a 100644
--- a/vmlauncher_app/Android.bp
+++ b/vmlauncher_app/Android.bp
@@ -10,6 +10,10 @@
         "androidx-constraintlayout_constraintlayout",
         "androidx.appcompat_appcompat",
         "com.google.android.material_material",
+        // TODO(b/330257000): will be removed when binder RPC is used
+        "android.system.virtualizationservice_internal-java",
+        // TODO(b/331708504): will be removed when AVF framework handles surface
+        "libcrosvm_android_display_service-java",
     ],
     libs: [
         "framework-virtualization.impl",
diff --git a/vmlauncher_app/AndroidManifest.xml b/vmlauncher_app/AndroidManifest.xml
index de9d094..860c03f 100644
--- a/vmlauncher_app/AndroidManifest.xml
+++ b/vmlauncher_app/AndroidManifest.xml
@@ -7,7 +7,11 @@
     <uses-feature android:name="android.software.virtualization_framework" android:required="true" />
     <application
         android:label="VmLauncherApp">
-        <activity android:name=".MainActivity" android:exported="true">
+        <activity android:name=".MainActivity"
+                  android:screenOrientation="landscape"
+                  android:configChanges="orientation|screenSize|keyboard|keyboardHidden|navigation|uiMode"
+                  android:theme="@style/MyTheme"
+                  android:exported="true">
             <intent-filter>
                 <action android:name="android.intent.action.MAIN" />
                 <category android:name="android.intent.category.LAUNCHER" />
diff --git a/vmlauncher_app/java/com/android/virtualization/vmlauncher/MainActivity.java b/vmlauncher_app/java/com/android/virtualization/vmlauncher/MainActivity.java
index 7c927c9..2af1e2f 100644
--- a/vmlauncher_app/java/com/android/virtualization/vmlauncher/MainActivity.java
+++ b/vmlauncher_app/java/com/android/virtualization/vmlauncher/MainActivity.java
@@ -20,6 +20,10 @@
 
 import android.app.Activity;
 import android.os.Bundle;
+import android.os.RemoteException;
+import android.os.ServiceManager;
+import android.crosvm.ICrosvmAndroidDisplayService;
+import android.system.virtualizationservice_internal.IVirtualizationServiceInternal;
 import android.system.virtualmachine.VirtualMachineCustomImageConfig;
 import android.util.Log;
 import android.system.virtualmachine.VirtualMachine;
@@ -27,6 +31,11 @@
 import android.system.virtualmachine.VirtualMachineConfig;
 import android.system.virtualmachine.VirtualMachineException;
 import android.system.virtualmachine.VirtualMachineManager;
+import android.view.SurfaceHolder;
+import android.view.SurfaceView;
+import android.view.WindowManager;
+import android.view.WindowInsets;
+import android.view.WindowInsetsController;
 
 import org.json.JSONArray;
 import org.json.JSONException;
@@ -108,6 +117,7 @@
     @Override
     protected void onCreate(Bundle savedInstanceState) {
         super.onCreate(savedInstanceState);
+        getWindow().setDecorFitsSystemWindows(false);
         setContentView(R.layout.activity_main);
         VirtualMachineCallback callback =
                 new VirtualMachineCallback() {
@@ -184,6 +194,70 @@
         } catch (VirtualMachineException e) {
             throw new RuntimeException(e);
         }
+
+        SurfaceView surfaceView = findViewById(R.id.surface_view);
+        surfaceView
+                .getHolder()
+                .addCallback(
+                        // TODO(b/331708504): it should be handled in AVF framework.
+                        new SurfaceHolder.Callback() {
+                            @Override
+                            public void surfaceCreated(SurfaceHolder holder) {
+                                Log.d(
+                                        TAG,
+                                        "surface size: "
+                                                + holder.getSurfaceFrame().flattenToString());
+                                Log.d(
+                                        TAG,
+                                        "ICrosvmAndroidDisplayService.setSurface("
+                                                + holder.getSurface()
+                                                + ")");
+                                runWithDisplayService(
+                                        (service) -> service.setSurface(holder.getSurface()));
+                            }
+
+                            @Override
+                            public void surfaceChanged(
+                                    SurfaceHolder holder, int format, int width, int height) {
+                                Log.d(TAG, "width: " + width + ", height: " + height);
+                            }
+
+                            @Override
+                            public void surfaceDestroyed(SurfaceHolder holder) {
+                                Log.d(TAG, "ICrosvmAndroidDisplayService.removeSurface()");
+                                runWithDisplayService((service) -> service.removeSurface());
+                            }
+                        });
+        getWindow().addFlags(WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON);
+
+        // Fullscreen:
+        WindowInsetsController windowInsetsController = surfaceView.getWindowInsetsController();
+        windowInsetsController.setSystemBarsBehavior(
+                WindowInsetsController.BEHAVIOR_SHOW_TRANSIENT_BARS_BY_SWIPE);
+        windowInsetsController.hide(WindowInsets.Type.systemBars());
+    }
+
+    @FunctionalInterface
+    public interface RemoteExceptionCheckedFunction<T> {
+        void apply(T t) throws RemoteException;
+    }
+
+    private void runWithDisplayService(
+            RemoteExceptionCheckedFunction<ICrosvmAndroidDisplayService> func) {
+        IVirtualizationServiceInternal vs =
+                IVirtualizationServiceInternal.Stub.asInterface(
+                        ServiceManager.getService("android.system.virtualizationservice"));
+        try {
+            assert vs != null;
+            Log.d(TAG, "wait for the service");
+            ICrosvmAndroidDisplayService service =
+                    ICrosvmAndroidDisplayService.Stub.asInterface(vs.waitDisplayService());
+            assert service != null;
+            func.apply(service);
+            Log.d(TAG, "job done");
+        } catch (Exception e) {
+            Log.d(TAG, "error", e);
+        }
     }
 
     /** Reads data from an input stream and posts it to the output data */
diff --git a/vmlauncher_app/res/layout/activity_main.xml b/vmlauncher_app/res/layout/activity_main.xml
index 5cbda78..6cc899f 100644
--- a/vmlauncher_app/res/layout/activity_main.xml
+++ b/vmlauncher_app/res/layout/activity_main.xml
@@ -7,12 +7,10 @@
     android:scrollbars="horizontal|vertical"
     android:textAlignment="textStart"
     tools:context=".MainActivity">
-
-    <LinearLayout
+    <SurfaceView
+        android:id="@+id/surface_view"
+        android:focusable="true"
         android:layout_width="match_parent"
-        android:layout_height="match_parent"
-        android:orientation="vertical">
-
-    </LinearLayout>
+        android:layout_height="match_parent" />
 
 </androidx.constraintlayout.widget.ConstraintLayout>
diff --git a/vmlauncher_app/res/values/themes.xml b/vmlauncher_app/res/values/themes.xml
new file mode 100644
index 0000000..395f089
--- /dev/null
+++ b/vmlauncher_app/res/values/themes.xml
@@ -0,0 +1,14 @@
+
+<resources xmlns:tools="http://schemas.android.com/tools">
+    <style name="MyTheme" parent="@android:style/Theme.DeviceDefault.NoActionBar">
+        <item name="android:navigationBarColor">
+            @android:color/transparent
+        </item>
+        <item name="android:statusBarColor">
+            @android:color/transparent
+        </item>
+        <item name="android:windowLayoutInDisplayCutoutMode">
+            shortEdges
+        </item>
+    </style>
+</resources>