【Android源码】资源加载AssetManager源码分析 app是如何加载资源以及我们是如何从内存中获取...

最新推荐文章于 2024-05-01 01:02:30 发布
最新推荐文章于 2024-05-01 01:02:30 发布
阅读量465 收藏 1
点赞数
文章标签： 移动开发 java 数据结构与算法
原文链接：https://juejin.im/post/5a322cdb6fb9a0452405d9e3
版权

通常情况下，当我们需要使用资源的时候，都是通过api直接调用:

getResources().getDrawable(R.mipmap.ic_launcher);
复制代码

通过getResources()的众多方法可以获取到整个apk包里面的资源，那么我们是如何获取到资源的？这些资源又是如何被加载到内存中的？ 今天我们来一起分析一下app是如何加载资源文件的。

资源加载过程

首先我们通过getResources()来看一下Resource是在哪里被创建出来的。

// AppCompatActivity.java
@Override
public Resources getResources() {
   if (mResources == null && VectorEnabledTintResources.shouldBeUsed()) {
       mResources = new VectorEnabledTintResources(this, super.getResources());
   }
   return mResources == null ? super.getResources() : mResources;
}

// Context.java
public abstract Resources getResources();
复制代码

一路点击过去发现，最终又到了Context这个上下文中，而Context是一个抽象类，所以我们需要找到其实现类ContextImpl.java。

// ContextImpl.java
@Override
public Resources getResources() {
   return mResources;
}

private ContextImpl(ContextImpl container, ActivityThread mainThread,
       LoadedApk packageInfo, IBinder activityToken, UserHandle user, int flags,
       Display display, Configuration overrideConfiguration, int createDisplayWithId) {
            
	Resources resources = packageInfo.getResources(mainThread);
	mResources = resources;	
}

// LoadedApk.java
public Resources getResources(ActivityThread mainThread) {
   if (mResources == null) {
       mResources = mainThread.getTopLevelResources(mResDir, mSplitResDirs, mOverlayDirs,
               mApplicationInfo.sharedLibraryFiles, Display.DEFAULT_DISPLAY, this);
   }
   return mResources;
}

// ResourcesManager.java
Resources getTopLevelResources(String resDir, String[] splitResDirs, String[] overlayDirs,
       String[] libDirs, int displayId, LoadedApk pkgInfo) {
   return mResourcesManager.getResources(null, resDir, splitResDirs, overlayDirs, libDirs,
           displayId, null, pkgInfo.getCompatibilityInfo(), pkgInfo.getClassLoader());
}
复制代码

发现在ContextImpl.java中Resources是被ResourcesManager的getTopLevelResources方法返回的。ResourcesManager是资源的管理类，我们着重看一下它。

public @NonNull Resources getResources(@Nullable IBinder activityToken,
       @Nullable String resDir,
       @Nullable String[] splitResDirs,
       @Nullable String[] overlayDirs,
       @Nullable String[] libDirs,
       int displayId,
       @Nullable Configuration overrideConfig,
       @NonNull CompatibilityInfo compatInfo,
       @Nullable ClassLoader classLoader) {
   try {
       Trace.traceBegin(Trace.TRACE_TAG_RESOURCES, "ResourcesManager#getResources");
       // 生成资源key对象
       final ResourcesKey key = new ResourcesKey(
               resDir,
               splitResDirs,
               overlayDirs,
               libDirs,
               displayId,
               overrideConfig != null ? new Configuration(overrideConfig) : null, // Copy
               compatInfo);
       classLoader = classLoader != null ? classLoader : ClassLoader.getSystemClassLoader();
       return getOrCreateResources(activityToken, key, classLoader);
   } finally {
       Trace.traceEnd(Trace.TRACE_TAG_RESOURCES);
   }
}

private @NonNull Resources getOrCreateResources(@Nullable IBinder activityToken,
       @NonNull ResourcesKey key, @NonNull ClassLoader classLoader) {
   synchronized (this) {

			// 从缓存中获取Resources
       if (activityToken != null) {
           final ActivityResources activityResources =
                   getOrCreateActivityResourcesStructLocked(activityToken);
				// 通过资源key对象获取缓存Resources
           ResourcesImpl resourcesImpl = findResourcesImplForKeyLocked(key);
           if (resourcesImpl != null) {
               if (DEBUG) {
                   Slog.d(TAG, "- using existing impl=" + resourcesImpl);
               }
               return getOrCreateResourcesForActivityLocked(activityToken, classLoader,
                       resourcesImpl);
           }
       } else {
       		// 通过资源key对象获取缓存Resources
           ResourcesImpl resourcesImpl = findResourcesImplForKeyLocked(key);
           if (resourcesImpl != null) {
               if (DEBUG) {
                   Slog.d(TAG, "- using existing impl=" + resourcesImpl);
               }
               return getOrCreateResourcesLocked(classLoader, resourcesImpl);
           }
       }
   }

   // 没有缓存创建ResourcesImpl
   ResourcesImpl resourcesImpl = createResourcesImpl(key);

   synchronized (this) {
   		// 通过资源key对象获取缓存Resources
       ResourcesImpl existingResourcesImpl = findResourcesImplForKeyLocked(key);
       if (existingResourcesImpl != null) {
           resourcesImpl.getAssets().close();
           resourcesImpl = existingResourcesImpl;
       } else {
           // 如果缓存中没有，将创建好的ResourceImpl加入到缓存中
           mResourceImpls.put(key, new WeakReference<>(resourcesImpl));
       }

       final Resources resources;
       if (activityToken != null) {
       		// 通过资源key对象获取缓存Resources
           resources = getOrCreateResourcesForActivityLocked(activityToken, classLoader,
                   resourcesImpl);
       } else {
       		// 通过资源key对象获取缓存Resources
           resources = getOrCreateResourcesLocked(classLoader, resourcesImpl);
       }
       return resources;
   }
}
复制代码

生成资源Resources对象的步骤：

  1. 首先生成资源Key对象，用于将资源对象添加到缓存map中或者从缓存map中查找资源对象
  2. 通过activityToken判断是否关联Activity，并从缓存中通过key获取缓存的ResourcesImpl对象，如果有直接返回
  3. 如果没有缓存的ResourcesImpl对象，则直接创建新的缓存ResourcesImpl对象，通过createResourcesImpl(key)来创建。
  4. 创建完之后在将其加入缓存Map中，并最终返回Resources.setImpl(impl)方法，创建出Resources对象并返回。

所以我们需要着重看下createResourcesImpl方法，这个方法才是创建ResourcesImpl的核心。

private @NonNull ResourcesImpl createResourcesImpl(@NonNull ResourcesKey key) {
   final DisplayAdjustments daj = new DisplayAdjustments(key.mOverrideConfiguration);
   daj.setCompatibilityInfo(key.mCompatInfo);

   final AssetManager assets = createAssetManager(key);
   final DisplayMetrics dm = getDisplayMetrics(key.mDisplayId, daj);
   final Configuration config = generateConfig(key, dm);
   final ResourcesImpl impl = new ResourcesImpl(assets, dm, config, daj);
   if (DEBUG) {
       Slog.d(TAG, "- creating impl=" + impl + " with key: " + key);
   }
   return impl;
}
复制代码

可以发现这儿方法创建了AssetManager资产管理类：

@VisibleForTesting
protected @NonNull AssetManager createAssetManager(@NonNull final ResourcesKey key) {
   AssetManager assets = new AssetManager();
   if (key.mResDir != null) {
       if (assets.addAssetPath(key.mResDir) == 0) {
           throw new Resources.NotFoundException("failed to add asset path " + key.mResDir);
       }
   }
   return assets;
}

// LoadedApk.java
private void setApplicationInfo(ApplicationInfo aInfo) {
   final int myUid = Process.myUid();
   aInfo = adjustNativeLibraryPaths(aInfo);
   mApplicationInfo = aInfo;
   mAppDir = aInfo.sourceDir;
   mResDir = aInfo.uid == myUid ? aInfo.sourceDir : aInfo.publicSourceDir;
}
复制代码

AssetManager是用来加载制定路径下的资源文件的，所以我们想要获取的资源文件都是在这个类中找到的。而key.mResDir就是app的资源路径。

所以AssetManager才是整个资源加载的关键所在。

public AssetManager() {
   synchronized (this) {
       if (DEBUG_REFS) {
           mNumRefs = 0;
           incRefsLocked(this.hashCode());
       }
       init(false);
       if (localLOGV) Log.v(TAG, "New asset manager: " + this);
       ensureSystemAssets();
   }
}

private native final void init(boolean isSystem);

private native final int loadResourceValue(int ident, short density, TypedValue outValue,
            boolean resolve);
复制代码

在创建AssetManager的时候，它首先会去调用native层中的init方法

static void android_content_AssetManager_init(JNIEnv* env, jobject clazz, jboolean isSystem)
{
    if (isSystem) {
        verifySystemIdmaps();
    }
    //  AssetManager.cpp
    AssetManager* am = new AssetManager();
    if (am == NULL) {
        jniThrowException(env, "java/lang/OutOfMemoryError", "");
        return;
    }

    am->addDefaultAssets();

    ALOGV("Created AssetManager %p for Java object %p\n", am, clazz);
    env->SetLongField(clazz, gAssetManagerOffsets.mObject, reinterpret_cast<jlong>(am));
}

bool AssetManager::addDefaultAssets()
{
    const char* root = getenv("ANDROID_ROOT");
    LOG_ALWAYS_FATAL_IF(root == NULL, "ANDROID_ROOT not set");

    String8 path(root);
    // kSystemAssets -> framework/framework-res.apk  
    // 加载系统的资源如颜色、图片、文字
    path.appendPath(kSystemAssets);

    return addAssetPath(path, NULL);
}

bool AssetManager::addAssetPath(const String8& path, int32_t* cookie)
{
    asset_path ap;

    // 判断是否已经加载过了
    for (size_t i=0; i<mAssetPaths.size(); i++) {
        if (mAssetPaths[i].path == ap.path) {
            if (cookie) {
                *cookie = static_cast<int32_t>(i+1);
            }
            return true;
        }
    }

    // 检查路径是否有一个androidmanifest.xml
    Asset* manifestAsset = const_cast<AssetManager*>(this)->openNonAssetInPathLocked(
            kAndroidManifest, Asset::ACCESS_BUFFER, ap);
    if (manifestAsset == NULL) {
        // 如果不包含任何资源
        delete manifestAsset;
        return false;
    }
    delete manifestAsset;
    // 添加 
    mAssetPaths.add(ap);
    if (mResources != NULL) {
        appendPathToResTable(ap);
    }

    return true;
}

bool AssetManager::appendPathToResTable(const asset_path& ap) const {

    Asset* ass = NULL;
    ResTable* sharedRes = NULL;
    bool shared = true;
    bool onlyEmptyResources = true;
    MY_TRACE_BEGIN(ap.path.string());

    Asset* idmap = openIdmapLocked(ap);
    size_t nextEntryIdx = mResources->getTableCount();
    ALOGV("Looking for resource asset in '%s'\n", ap.path.string());
    // 资源包路径不是一个文件夹
    if (ap.type != kFileTypeDirectory) {
        if (nextEntryIdx == 0) {
            // mAssetPaths中存储的第一个资源包路径是系统资源的路径，
            // 即framework-res.apk的路径，它在zygote启动时已经加载了
            // 可以通过mZipSet.getZipResourceTable获得其ResTable对象
            sharedRes = const_cast<AssetManager*>(this)->
                mZipSet.getZipResourceTable(ap.path);
            // 对于APP来说，肯定不为NULL
            if (sharedRes != NULL) {
                // 得到系统资源包路径中resources.arsc个数
                nextEntryIdx = sharedRes->getTableCount();
            }
        }
        // 当参数是mAssetPaths中除第一个以外的其他资源资源包路径，
        // 比如app自己的资源包路径时，走下面的逻辑
        if (sharedRes == NULL) {
            // 检查该资源包是否被其他进程加载了，这与ZipSet数据结构有关，后面在详细介绍
            ass = const_cast<AssetManager*>(this)->
                mZipSet.getZipResourceTableAsset(ap.path);
            if (ass == NULL) {
                ALOGV("loading resource table %s\n", ap.path.string());
                // 创建Asset对象，就是打开resources.arsc
                ass = const_cast<AssetManager*>(this)->
                    openNonAssetInPathLocked("resources.arsc",
                                             Asset::ACCESS_BUFFER,
                                             ap);
                if (ass != NULL && ass != kExcludedAsset) {
                    ass = const_cast<AssetManager*>(this)->
                        mZipSet.setZipResourceTableAsset(ap.path, ass);
                }
            }
            // 只有在zygote启动时，才会执行下面的逻辑
            // 为系统资源创建 ResTable，并加入到mZipSet里。
            if (nextEntryIdx == 0 && ass != NULL) {
                ALOGV("Creating shared resources for %s", ap.path.string());
                // 创建ResTable对象，并把前面与resources.arsc关联的Asset对象，加入到这个ResTabl中
                sharedRes = new ResTable();
                sharedRes->add(ass, idmap, nextEntryIdx + 1, false);
                sharedRes = const_cast<AssetManager*>(this)->
                    mZipSet.setZipResourceTable(ap.path, sharedRes);
            }
        }
    } else {
        ALOGV("loading resource table %s\n", ap.path.string());
        ass = const_cast<AssetManager*>(this)->
            openNonAssetInPathLocked("resources.arsc",
                                     Asset::ACCESS_BUFFER,
                                     ap);
        shared = false;
    }

    if ((ass != NULL || sharedRes != NULL) && ass != kExcludedAsset) {
        ALOGV("Installing resource asset %p in to table %p\n", ass, mResources);
        // 系统资源包时
        if (sharedRes != NULL) {
            ALOGV("Copying existing resources for %s", ap.path.string());
            mResources->add(sharedRes);
        } else {
            // 非系统资源包时，将与resources.arsc关联的Asset对象加入到Restable中
            // 此过程会解析resources.arsc文件。
            ALOGV("Parsing resources for %s", ap.path.string());
            mResources->add(ass, idmap, nextEntryIdx + 1, !shared);
        }
        onlyEmptyResources = false;

        if (!shared) {
            delete ass;
        }
    } else {
        mResources->addEmpty(nextEntryIdx + 1);
    }

    if (idmap != NULL) {
        delete idmap;
    }
    MY_TRACE_END();

    return onlyEmptyResources;
}
复制代码

获取系统路径并解析resources.arsc这个文件映射表，其中存放的就是资源的索引。

至此，系统资源加载就完成了。

获取资源

现在所有资源的索引已经加载到内存中了，我们就需要获取资源并加载了。

<ImageView
   android:layout_width="wrap_content"
   android:layout_height="wrap_content"
   android:src="@drawable/image"/>
复制代码

我们看一下ImageView的src属性图片是如何加载的，通常情况下，src属性和我们自定义属性很想，都是自定义的属性，只不过一个是系统定义的，一个是我们定义的，所有我们直接看ImageView的构造函数：

public ImageView(Context context, @Nullable AttributeSet attrs, int defStyleAttr,
       int defStyleRes) {
   super(context, attrs, defStyleAttr, defStyleRes);
   final TypedArray a = context.obtainStyledAttributes(
                attrs, R.styleable.ImageView, defStyleAttr, defStyleRes);

   final Drawable d = a.getDrawable(R.styleable.ImageView_src);
	if (d != null) {
       setImageDrawable(d);
   }   
}

@Nullable
public Drawable getDrawable(@StyleableRes int index) {
   final TypedValue value = mValue;
   if (getValueAt(index*AssetManager.STYLE_NUM_ENTRIES, value)) {
       if (value.type == TypedValue.TYPE_ATTRIBUTE) {
           throw new UnsupportedOperationException(
                   "Failed to resolve attribute at index " + index + ": " + value);
       }
       return mResources.loadDrawable(value, value.resourceId, mTheme);
   }
   return null;
}
复制代码

最后也是通过Resources的loadDrawable(value, value.resourceId, mTheme)方法来获取到资源：

// Resources.java
@NonNull
Drawable loadDrawable(@NonNull TypedValue value, int id, @Nullable Theme theme)
       throws NotFoundException {
   return mResourcesImpl.loadDrawable(this, value, id, theme, true);
}

// ResourcesImpl.java
@Nullable
Drawable loadDrawable(Resources wrapper, TypedValue value, int id, Resources.Theme theme,
       boolean useCache) throws NotFoundException {
   try {
       Drawable dr;
       if (cs != null) {
           dr = cs.newDrawable(wrapper);
       } else if (isColorDrawable) {
           dr = new ColorDrawable(value.data);
       } else {
           dr = loadDrawableForCookie(wrapper, value, id, null);
       }

       return dr;
   } catch (Exception e) {
       throw nfe;
   }
}
复制代码

加载drawable的时候，首先会现在缓存中获取，如果有就直接返回，如果没有的话，说明没有加载过这个资源文件，就需要先加载并缓存到caches中，所有我们看loadDrawableForCookie方法：

private Drawable loadDrawableForCookie(Resources wrapper, TypedValue value, int id,
       Resources.Theme theme) {
   final String file = value.string.toString();

   final Drawable dr;

   Trace.traceBegin(Trace.TRACE_TAG_RESOURCES, file);
   try {
       if (file.endsWith(".xml")) {
       	// 类似于shape的xml文件
           final XmlResourceParser rp = loadXmlResourceParser(
                   file, id, value.assetCookie, "drawable");
           dr = Drawable.createFromXml(wrapper, rp, theme);
           rp.close();
       } else {
       	// 不是xml文件，就是图片文件，就将其加载到内存中
       	// value.assetCookie这个cookie就是图片在native层中的mAssetPaths中的索引
           final InputStream is = mAssets.openNonAsset(
                   value.assetCookie, file, AssetManager.ACCESS_STREAMING);
           dr = Drawable.createFromResourceStream(wrapper, value, is, file, null);
           is.close();
       }
   } catch (Exception e) {
       Trace.traceEnd(Trace.TRACE_TAG_RESOURCES);
       final NotFoundException rnf = new NotFoundException(
               "File " + file + " from drawable resource ID #0x" + Integer.toHexString(id));
       rnf.initCause(e);
       throw rnf;
   }
   Trace.traceEnd(Trace.TRACE_TAG_RESOURCES);

   return dr;
}
复制代码

loadDrawableForCookie方法会首先判断是否是.xml文件，如果是xml文件，则直接使用xml解析并创建Drawable对象返回，如果不是xml文件，则认为是图片的资源文件，使用流的方式将资源读取到缓存中。

至此为止，资源是如何加载的和如何从内存中获取资源都完成了。

weixin_34190136
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
从内存中提取图片等数据
01-14
从内存中提取图片等数据从内存中提取图片等数据从内存中提取图片等数据从内存中提取图片等数据
Android 基于JBox2D的Android游戏开发全源码-IT计算机-毕业设计.zip
04-05
6. **资源管理**：在Android游戏中，资源如图像、音频、数据文件等需要被有效地加载和管理。理解如何使用AssetManager和XML资源文件是提高游戏性能的关键。 7. **调试与优化**：源码分析和调试是提升代码质量的重要...
android 指定资源id,Android中实现根据资源名获取资源ID
weixin_36018748的博客
05-25 642
接触过Android开发的同学们都知道在Android中访问程序资源基本都是通过资源ID来访问。这样开发起来很简单，并且可以不去考虑各种分辨率，语言等不同资源显式指定。痛点但是，有时候也会有一些问题，比如我们根据服务器端的值取图片，但是服务器端绝对不会返回给我们的是资源id，最多是一种和文件名相关联的值，操作资源少的时候，可以维护一个容器进行值与资源ID的映射，但是多的话，就需要另想办法了。便捷的...
android 报错java.io.IOException: Failed to load asset path
最新发布
jacke121的专栏
05-01 1641
android 报错java.io.IOException: Failed to load asset path
AssetsManager
modabobo
10-22 119
// Remove downloaded files #if (CC_TARGET_PLATFORM != CC_PLATFORM_WIN32) string command = "rm -r "; // Path may include space. command += "\"" + pathToSave + "\""; system(command.c_str()); #...
Android插件换肤之AssetManager相关源码分析
qq_36523667的博客
05-16 695
学习自https://www.jianshu.com/p/5eac94143bd6本文可不看 没啥意义AssetManager.mObject是native层的AssetManager /** * Create a new AssetManager containing only the basic system assets. * Applications will ...
AssetsManager资源管理器
幺鸡报晓的博客
03-17 543
原文：https://github.com/libgdx/libgdx/wiki/Managing-your-assets
Android应用源码之(View游戏框架)-IT计算机-毕业设计.zip
04-06
- 资源加载与释放：有效管理内存，避免内存泄漏，如使用AssetManager加载音频、图片等资源。 - 资源打包：将游戏资源打包成Asset或raw文件，便于程序访问。 8. **音频与音乐**： - MediaPlayer：播放背景音乐。 ...
Android应用源码之(飞行射击游戏实战-IT计算机-毕业设计.zip
04-06
在这个项目中，我们将探讨Android游戏开发的基本原理、关键技术以及源码分析。 1. **Android游戏架构** - 游戏通常包含游戏引擎、渲染引擎、物理引擎、音频引擎等多个组件。在Android中，这些组件可能以Activity、...
Android应用源码之(操作游戏主角)-IT计算机-毕业设计.zip
04-06
通过分析这个"操作游戏主角"的Android应用源码，不仅可以学习到Android的基础知识，还能深入了解游戏开发中的高级技巧，对于提升Android毕业设计的完成度和专业性具有很大帮助。在实践中不断探索和调试，能让你更好...
Android高级应用源码-微信打灰机源码.zip
10-14
最后，考虑到性能优化，源码中可能包含了一些Android的性能最佳实践，例如异步加载资源、多线程处理复杂计算、内存管理以及使用高效的算法和数据结构。此外，为了确保游戏在不同设备上的兼容性，开发者可能采用了...
Android热修复原理+实现(最全方案)
08-05
本课程包含目前所有Android热修复框架的方案，深入解析各种方案原理+手动实现验证。包括代码修复（dex插桩、字节码插桩、native hook方法替换）、资源修复（0x66资源补丁、AssetManager对象替换）、so修复（接口替换、反射方案）。学完本课程相当于掌握了所有热修复技术原理及框架。课程内容丰富有深度，4k录制高清视频。
0xA03 Android 10 源码分析：APK 加载流程之资源加载
公众号：ByteCode
05-05 958
引言 这是 Android 10 源码分析系列的第 3 篇 分支：android-10.0.0_r14 全文阅读大概 15 分钟 通过这篇文章你将学习到以下内容，文末会给出相应的答案 LayoutInflater的inflate 方法的三个参数都代表什么意思？ 系统对 merge、include 是如何处理的 merge 标签为什么可以起到优化布局的效果？ XML 中的 View 是如...
Android资源管理中的Runtime Resources Overlay-------之overlay包的加载（四）
大勇的专栏
07-19 1970
        前文我们介绍了idmap文件的生成过程，剩下来的就是overlay package和idmap的加载和生效了。 overlay package和idmap文件的加载         我们在Android资源管理中的Runti...
systrace/perfetto中需要actrace打tag相关方法-车载车机framework系统开发实战
learnframework的博客
10-07 957
正因为有了系统中各个地方埋下的这些tag，才让我们可以根据这些方法tag分析出整个系统的运行情况。但是大家有没有想过，请问这些tag是怎么打上去的？如果我们自己要打印自己方法的tag应该怎么搞？
android rro技术,自定义Android资源覆盖rro方案
weixin_29094979的博客
06-02 1156
1. framework层rro资源覆盖方案在\framework\base\core\jni\android_util_AssetManager.cpp中： before：12345678910111213141516171819202122232425262728291234567891011121314151617181920212223242526272829static void an...
解析软件安装包错误PackageParserException-- Failed adding asset path解决方法
热门推荐
shanshan_blog的博客
11-03 1万+
这两天领导给安排了任务，app通知栏自动下载更新并安装。经过查看相关资料，app通知栏自动下载更新，很快就实现了，但是自动安装却总报错“解析软件安装包错误！”，也查了很多资料，但基本都是讲解安装原理的，并没有关于出现错误的解决方法。不得已，我查看了logcat日志，看到了错误根源。can not parse packag                                  andr
Android应用程序资源管理器（Asset Manager）的创建过程分析
weixin_30820151的博客
04-22 308
在前面一篇文章中，我们分析了Android应用程序资源的编译和打包过程，最终得到的应用程序资源就与应用程序代码一起打包在一个APK文件中。Android应用程序在运行的过程中，是通过一个称为AssetManager的资源管理器来读取打包在APK文件里面的资源文件的。在本文中，我们就将详细分析Android应用程序资源管理器的创建以及初始化过程，为接下来的一篇文章分析应用程序资源...
Cocos Creator 3.7版本加载远程资源使用assetManager
03-27
在Cocos Creator 3.7中，可以使用assetManager来加载远程资源。以下是使用assetManager加载远程图片的示例代码： ```typescript cc.assetManager.loadRemote('http://www.example.com/image.png', {ext: '.png'}, (err, texture) => { if (err) { cc.error(err.message || err); return; } // 使用加载成功的纹理 const sprite = node.getComponent(cc.Sprite); sprite.spriteFrame = new cc.SpriteFrame(texture); }); ``` 在此示例中，我们传递了远程图片的URL和扩展名（这里是“.png”），然后在回调中检查是否有错误。如果加载成功，我们可以使用纹理创建一个精灵帧，并将其设置为节点上的精灵组件的spriteFrame属性。 除了loadRemote方法，assetManager还提供了其他方法来加载远程资源，如loadAny、loadJson和loadText等。可以根据需要选择适当的方法。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值