Preparing bundle mode for Android

grendello · grendello · commit 8ffce8bba911 · 2025-01-28T22:08:50.000+01:00
diff --git a/src/coreclr/dlls/mscoree/exports.cpp b/src/coreclr/dlls/mscoree/exports.cpp
@@ -169,7 +169,8 @@ static void ConvertConfigPropertiesToUnicode(
     *propertyKeysWRef = propertyKeysW;
     *propertyValuesWRef = propertyValuesW;
 }
-#endif
+
+#else // TARGET_ANDROID
 
 static void ConvertConfigPropertiesToUnicode(
     const char** propertyKeys,
@@ -229,7 +230,7 @@ static void ConvertConfigPropertiesToUnicode(
     *propertyKeysWRef = propertyKeysW;
     *propertyValuesWRef = propertyValuesW;
 }
-
+#endif // !TARGET_ANDROID
 coreclr_error_writer_callback_fn g_errorWriter = nullptr;
 
 //
@@ -289,7 +290,7 @@ int android_coreclr_initialize(
         return HOST_E_INVALIDOPERATION;
     }
 
-    if (hostContract->bundle_probe == nullptr) { [[unlikely]]
+    if (hostContract->android_bundle_probe == nullptr) { [[unlikely]]
         LogErrorToLogcat(ANDROID_LOG_FATAL, "Host contract isn't initialized properly: missing bundle probe handler.");
         return HOST_E_INVALIDOPERATION;
     }
@@ -317,7 +318,7 @@ int android_coreclr_initialize(
     hr = CorHost2::CreateObject(IID_ICLRRuntimeHost4, (void**)&host);
     IfFailRet(hr);
 
-    static Bundle bundle(appName, hostContract->bundle_probe);
+    static Bundle bundle(appName, hostContract->android_bundle_probe);
     Bundle::AppBundle = &bundle;
 
     // This will take ownership of propertyKeysWTemp and propertyValuesWTemp
@@ -349,6 +350,7 @@ int android_coreclr_initialize(
     }
     return hr;
 }
+
 #endif // TARGET_ANDROID
 
 //
@@ -378,6 +380,7 @@ int coreclr_initialize(
             void** hostHandle,
             unsigned int* domainId)
 {
+#if !defined(TARGET_ANDROID)
     HRESULT hr;
 
     LPCWSTR* propertyKeysW;
@@ -482,6 +485,9 @@ int coreclr_initialize(
 #endif
     }
     return hr;
+#else // TARGET_ANDROID
+    return HOST_E_INVALIDOPERATION;
+#endif
 }
 
 //
diff --git a/src/coreclr/hosts/inc/coreclrhost.h b/src/coreclr/hosts/inc/coreclrhost.h
@@ -169,7 +169,11 @@ CORECLR_HOSTING_API(coreclr_execute_assembly,
 //
 // Callback types used by the hosts
 //
+#if defined(TARGET_ANDROID)
+using BundleProbeFn = bool(const char* path, void** data_start, int64_t* size);
+#else
 typedef bool(CORECLR_CALLING_CONVENTION BundleProbeFn)(const char* path, int64_t* offset, int64_t* size, int64_t* compressedSize);
+#endif
 typedef const void* (CORECLR_CALLING_CONVENTION PInvokeOverrideFn)(const char* libraryName, const char* entrypointName);
 
 
diff --git a/src/coreclr/inc/bundle.h b/src/coreclr/inc/bundle.h
@@ -18,23 +18,37 @@ class Bundle;
 struct BundleFileLocation
 {
     INT64 Size;
+#if defined(TARGET_ANDROID)
+    void* DataStart;
+    constexpr static INT64 Offset = 0;
+    constexpr static INT64 UncompresedSize = 0;
+#else
     INT64 Offset;
     INT64 UncompresedSize;
+#endif
 
     BundleFileLocation()
-    { 
+    {
         LIMITED_METHOD_CONTRACT;
 
         Size = 0;
-        Offset = 0; 
+#if defined(TARGET_ANDROID)
+        DataStart = INVALID_HANDLE_VALUE;
+#else
+        Offset = 0;
         UncompresedSize = 0;
+#endif
     }
 
     static BundleFileLocation Invalid() { LIMITED_METHOD_CONTRACT; return BundleFileLocation(); }
 
     const SString &Path() const;
-
+#if defined(TARGET_ANDROID)
+    const SString &AppName() const;
+    bool IsValid() const { LIMITED_METHOD_CONTRACT; return DataStart != nullptr; }
+#else // TARGET_ANDROID
     bool IsValid() const { LIMITED_METHOD_CONTRACT; return Offset != 0; }
+#endif // !TARGET_ANDROID
 };
 
 class Bundle
@@ -51,12 +65,14 @@ class Bundle
     static BundleFileLocation ProbeAppBundle(const SString& path, bool pathIsBundleRelative = false);
 
 private:
-
+#if defined(TARGET_ANDROID)
+    SString m_appName;
+#endif
     SString m_path; // The path to single-file executable
     BundleProbeFn *m_probe;
 
     SString m_basePath; // The prefix to denote a path within the bundle
-    COUNT_T m_basePathLength;
+    COUNT_T m_basePathLength = 0;
 };
 
 #endif // _BUNDLE_H_
diff --git a/src/coreclr/vm/bundle.cpp b/src/coreclr/vm/bundle.cpp
@@ -30,14 +30,28 @@ const SString &BundleFileLocation::Path() const
     return Bundle::AppBundle->Path();
 }
 
+#if defined(TARGET_ANDROID)
+const SString &BundleFileLocation::AppName() const
+{
+    LIMITED_METHOD_CONTRACT;
+
+    _ASSERTE(IsValid());
+    _ASSERTE(Bundle::AppBundle != nullptr);
+
+    return Bundle::AppBundle->Path();
+}
+#endif
+
 Bundle::Bundle(LPCSTR bundlePath, BundleProbeFn *probe)
 {
     STANDARD_VM_CONTRACT;
 
     _ASSERTE(probe != nullptr);
-
-    m_path.SetUTF8(bundlePath);
     m_probe = probe;
+#if defined(TARGET_ANDROID)
+    m_appName.SetUTF8(bundlePath);
+#else
+    m_path.SetUTF8(bundlePath);
 
     // The bundle-base path is the directory containing the single-file bundle.
     // When the Probe() function searches within the bundle, it masks out the basePath from the assembly-path (if found).
@@ -47,6 +61,7 @@ Bundle::Bundle(LPCSTR bundlePath, BundleProbeFn *probe)
     size_t baseLen = pos - bundlePath + 1; // Include DIRECTORY_SEPARATOR_CHAR_A in m_basePath
     m_basePath.SetUTF8(bundlePath, (COUNT_T)baseLen);
     m_basePathLength = (COUNT_T)baseLen;
+#endif // !TARGET_ANDROID
 }
 
 BundleFileLocation Bundle::Probe(const SString& path, bool pathIsBundleRelative) const
@@ -64,6 +79,13 @@ BundleFileLocation Bundle::Probe(const SString& path, bool pathIsBundleRelative)
     pathBuffer.SetAndConvertToUTF8(path.GetUnicode());
     LPCSTR utf8Path(pathBuffer.GetUTF8());
 
+#if defined(TARGET_ANDROID)
+    // On Android we always strip away the assembly path, if any
+    LPCSTR pos = strrchr(utf8Path, DIRECTORY_SEPARATOR_CHAR_A);
+    if (pos != nullptr) {
+        utf8Path = pos + 1; // one past the last directory separator char
+    }
+#else // TARGET_ANDROID
     if (!pathIsBundleRelative)
     {
 #ifdef TARGET_UNIX
@@ -80,10 +102,13 @@ BundleFileLocation Bundle::Probe(const SString& path, bool pathIsBundleRelative)
             return loc;
         }
     }
-
+#endif // !TARGET_ANDROID
     INT64 fileSize = 0;
     INT64 compressedSize = 0;
 
+#if defined(TARGET_ANDROID)
+    m_probe(utf8Path, &loc.DataStart, &loc.Size);
+#else
     m_probe(utf8Path, &loc.Offset, &fileSize, &compressedSize);
 
     if (compressedSize)
@@ -96,7 +121,7 @@ BundleFileLocation Bundle::Probe(const SString& path, bool pathIsBundleRelative)
         loc.Size = fileSize;
         loc.UncompresedSize = 0;
     }
-
+#endif
     return loc;
 }
 
diff --git a/src/coreclr/vm/peimage.cpp b/src/coreclr/vm/peimage.cpp
@@ -850,7 +850,14 @@ HANDLE PEImage::GetFileHandle()
     if (m_hFile == INVALID_HANDLE_VALUE)
     {
 #if !defined(DACCESS_COMPILE)
-        EEFileLoadException::Throw(GetPathToLoad(), hr);
+        EEFileLoadException::Throw(
+#if defined(TARGET_ANDROID)
+            AndroidGetAppName(),
+#else
+            GetPathToLoad(),
+#endif
+            hr
+        );
 #else // defined(DACCESS_COMPILE)
         ThrowHR(hr);
 #endif // !defined(DACCESS_COMPILE)
@@ -869,6 +876,9 @@ HRESULT PEImage::TryOpenFile(bool takeLock)
         return S_OK;
 
     ErrorModeHolder mode{};
+#if defined(TARGET_ANDROID)
+    m_hFile = AndroidGetDataStart ();
+#else
     m_hFile=WszCreateFile((LPCWSTR)GetPathToLoad(),
                           GENERIC_READ
 #if TARGET_WINDOWS
@@ -881,7 +891,7 @@ HRESULT PEImage::TryOpenFile(bool takeLock)
                           OPEN_EXISTING,
                           FILE_ATTRIBUTE_NORMAL,
                           NULL);
-
+#endif
     if (m_hFile != INVALID_HANDLE_VALUE)
             return S_OK;
 
diff --git a/src/coreclr/vm/peimage.h b/src/coreclr/vm/peimage.h
@@ -133,7 +133,12 @@ class PEImage final
     PTR_PEImageLayout GetFlatLayout();
 
     const SString& GetPath();
+#if defined(TARGET_ANDROID)
+    const HANDLE AndroidGetDataStart();
+    const SString& AndroidGetAppName();
+#else
     const SString& GetPathToLoad();
+#endif
     LPCWSTR GetPathForErrorMessages() { return GetPath(); }
 
     BOOL IsFile();
diff --git a/src/coreclr/vm/peimage.inl b/src/coreclr/vm/peimage.inl
@@ -32,12 +32,25 @@ inline const SString &PEImage::GetPath()
     return m_path;
 }
 
+#if defined(TARGET_ANDROID)
+inline const HANDLE PEImage::AndroidGetDataStart()
+{
+    LIMITED_METHOD_CONTRACT;
+    return m_bundleFileLocation.DataStart;
+}
+
+inline const SString& PEImage::AndroidGetAppName()
+{
+    return m_bundleFileLocation.AppName();
+}
+#else
 inline const SString& PEImage::GetPathToLoad()
 {
     LIMITED_METHOD_DAC_CONTRACT;
 
     return IsInBundle() ? m_bundleFileLocation.Path() : m_path;
 }
+#endif // !TARGET_ANDROID
 
 inline INT64 PEImage::GetOffset() const
 {
@@ -98,8 +111,11 @@ inline const SString &PEImage::GetModuleFileNameHintForDAC()
 inline BOOL PEImage::IsFile()
 {
     WRAPPER_NO_CONTRACT;
-
+#if defined(TARGET_ANDROID)
+    return false;
+#else
     return !GetPathToLoad().IsEmpty();
+#endif
 }
 
 //
diff --git a/src/native/corehost/host_runtime_contract.h b/src/native/corehost/host_runtime_contract.h
@@ -38,6 +38,12 @@ struct host_runtime_contract
         size_t value_buffer_size,
         void* contract_context);
 
+#if defined(TARGET_ANDROID)
+    bool(HOST_CONTRACT_CALLTYPE* android_bundle_probe)(
+        const char* path,
+        void **data_start,
+        int64_t* size);
+#endif
     // Probe an app bundle for `path`. Sets its location (`offset`, `size`) in the bundle if found.
     // Returns true if found, false otherwise.
     bool(HOST_CONTRACT_CALLTYPE* bundle_probe)(

Original file line number	Diff line number	Diff line change
`@@ -169,7 +169,8 @@ static void ConvertConfigPropertiesToUnicode(`
`169`	`169`	`*propertyKeysWRef = propertyKeysW;`
`170`	`170`	`*propertyValuesWRef = propertyValuesW;`
`171`	`171`	`}`
`172`		`-#endif`
	`172`	`+`
	`173`	`+#else // TARGET_ANDROID`
`173`	`174`
`174`	`175`	`static void ConvertConfigPropertiesToUnicode(`
`175`	`176`	`const char** propertyKeys,`
`@@ -229,7 +230,7 @@ static void ConvertConfigPropertiesToUnicode(`
`229`	`230`	`*propertyKeysWRef = propertyKeysW;`
`230`	`231`	`*propertyValuesWRef = propertyValuesW;`
`231`	`232`	`}`
`232`		`-`
	`233`	`+#endif // !TARGET_ANDROID`
`233`	`234`	`coreclr_error_writer_callback_fn g_errorWriter = nullptr;`
`234`	`235`
`235`	`236`	`//`
`@@ -289,7 +290,7 @@ int android_coreclr_initialize(`
`289`	`290`	`return HOST_E_INVALIDOPERATION;`
`290`	`291`	`}`
`291`	`292`
`292`		`- if (hostContract->bundle_probe == nullptr) { [[unlikely]]`
	`293`	`+ if (hostContract->android_bundle_probe == nullptr) { [[unlikely]]`
`293`	`294`	`LogErrorToLogcat(ANDROID_LOG_FATAL, "Host contract isn't initialized properly: missing bundle probe handler.");`
`294`	`295`	`return HOST_E_INVALIDOPERATION;`
`295`	`296`	`}`
`@@ -317,7 +318,7 @@ int android_coreclr_initialize(`
`317`	`318`	`hr = CorHost2::CreateObject(IID_ICLRRuntimeHost4, (void**)&host);`
`318`	`319`	`IfFailRet(hr);`
`319`	`320`
`320`		`- static Bundle bundle(appName, hostContract->bundle_probe);`
	`321`	`+ static Bundle bundle(appName, hostContract->android_bundle_probe);`
`321`	`322`	`Bundle::AppBundle = &bundle;`
`322`	`323`
`323`	`324`	`// This will take ownership of propertyKeysWTemp and propertyValuesWTemp`
`@@ -349,6 +350,7 @@ int android_coreclr_initialize(`
`349`	`350`	`}`
`350`	`351`	`return hr;`
`351`	`352`	`}`
	`353`	`+`
`352`	`354`	`#endif // TARGET_ANDROID`
`353`	`355`
`354`	`356`	`//`
`@@ -378,6 +380,7 @@ int coreclr_initialize(`
`378`	`380`	`void** hostHandle,`
`379`	`381`	`unsigned int* domainId)`
`380`	`382`	`{`
	`383`	`+#if !defined(TARGET_ANDROID)`
`381`	`384`	`HRESULT hr;`
`382`	`385`
`383`	`386`	`LPCWSTR* propertyKeysW;`
`@@ -482,6 +485,9 @@ int coreclr_initialize(`
`482`	`485`	`#endif`
`483`	`486`	`}`
`484`	`487`	`return hr;`
	`488`	`+#else // TARGET_ANDROID`
	`489`	`+ return HOST_E_INVALIDOPERATION;`
	`490`	`+#endif`
`485`	`491`	`}`
`486`	`492`
`487`	`493`	`//`
Original file line number	Diff line number	Diff line change
`@@ -32,12 +32,25 @@ inline const SString &PEImage::GetPath()`
`32`	`32`	`return m_path;`
`33`	`33`	`}`
`34`	`34`
	`35`	`+#if defined(TARGET_ANDROID)`
	`36`	`+inline const HANDLE PEImage::AndroidGetDataStart()`
	`37`	`+{`
	`38`	`+ LIMITED_METHOD_CONTRACT;`
	`39`	`+ return m_bundleFileLocation.DataStart;`
	`40`	`+}`
	`41`	`+`
	`42`	`+inline const SString& PEImage::AndroidGetAppName()`
	`43`	`+{`
	`44`	`+ return m_bundleFileLocation.AppName();`
	`45`	`+}`
	`46`	`+#else`
`35`	`47`	`inline const SString& PEImage::GetPathToLoad()`
`36`	`48`	`{`
`37`	`49`	`LIMITED_METHOD_DAC_CONTRACT;`
`38`	`50`
`39`	`51`	`return IsInBundle() ? m_bundleFileLocation.Path() : m_path;`
`40`	`52`	`}`
	`53`	`+#endif // !TARGET_ANDROID`
`41`	`54`
`42`	`55`	`inline INT64 PEImage::GetOffset() const`
`43`	`56`	`{`
`@@ -98,8 +111,11 @@ inline const SString &PEImage::GetModuleFileNameHintForDAC()`
`98`	`111`	`inline BOOL PEImage::IsFile()`
`99`	`112`	`{`
`100`	`113`	`WRAPPER_NO_CONTRACT;`
`101`		`-`
	`114`	`+#if defined(TARGET_ANDROID)`
	`115`	`+ return false;`
	`116`	`+#else`
`102`	`117`	`return !GetPathToLoad().IsEmpty();`
	`118`	`+#endif`
`103`	`119`	`}`
`104`	`120`
`105`	`121`	`//`