热修复中的资源修复

public final int addAssetPath(String path) {
    synchronized (this) {
        int res = addAssetPathNative(path);
        makeStringBlocks(mStringBlocks);
        return res;
    }
}

static jint android_content_AssetManager_addAssetPath(JNIEnv* env, jobject clazz,
                                                      jstring path)
{
    ScopedUtfChars path8(env, path);
    if (path8.c_str() == NULL) {
        return 0;
    }
    AssetManager* am = assetManagerForJavaObject(env, clazz);
    if (am == NULL) {
        return 0;
    }
    void* cookie;
    bool res = am->addAssetPath(String8(path8.c_str()), &cookie);
    return (res) ? (jint)cookie : 0;
}

bool AssetManager::addAssetPath(const String8& path, int32_t* cookie)
{
 AutoMutex _l(mLock);

 asset_path ap;

 String8 realPath(path);
 if (kAppZipName) {
     realPath.appendPath(kAppZipName);
 }
 ap.type = ::getFileType(realPath.string());
 if (ap.type == kFileTypeRegular) {
     ap.path = realPath;
 } else {
     ap.path = path;
     ap.type = ::getFileType(path.string());
     if (ap.type != kFileTypeDirectory && ap.type != kFileTypeRegular) {
         ALOGW("Asset path %s is neither a directory nor file (type=%d).",
              path.string(), (int)ap.type);
         return false;
     }
 }

 // Skip if we have it already.
 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;
     }
 }

 ALOGV("In %p Asset %s path: %s", this,
      ap.type == kFileTypeDirectory ? "dir" : "zip", ap.path.string());

 // Check that the path has an AndroidManifest.xml
 Asset* manifestAsset = const_cast<AssetManager*>(this)-  >openNonAssetInPathLocked(
        kAndroidManifest, Asset::ACCESS_BUFFER, ap);
 if (manifestAsset == NULL) {
      // This asset path does not contain any resources.
      delete manifestAsset;
     return false;
 }
 delete manifestAsset;

 mAssetPaths.add(ap);

 // new paths are always added at the end
 if (cookie) {
     *cookie = static_cast<int32_t>(mAssetPaths.size());
 }

 // Load overlays, if any
 asset_path oap;
 for (size_t idx = 0; mZipSet.getOverlay(ap.path, idx, &oap); idx++) {
     mAssetPaths.add(oap);
 }

 if (mResources != NULL) {
     appendPathToResTable(ap);
 }

 return true;
}

ssize_t ResTable::getResource(uint32_t resID, Res_value* outValue, bool mayBeBag,
uint32_t* outSpecFlags, ResTable_config* outConfig) const{
  ......

  const ssize_t p = getResourcePackageIndex(resID);
  const int t = Res_GETTYPE(resID);
  const int e = Res_GETENTRY(resID);

  ......

  const Res_value* bestValue = NULL;
  const Package* bestPackage = NULL;
  ResTable_config bestItem;
  memset(&bestItem, 0, sizeof(bestItem)); // make the compiler shut up

  if (outSpecFlags != NULL) *outSpecFlags = 0;

  // Look through all resource packages, starting with the most
  // recently added.

  //Attention here!!!!!!!!!!!!
  const PackageGroup* const grp = mPackageGroups[p];
  ......

  size_t ip = grp->packages.size();
  while (ip > 0) {
      ip--;
      int T = t;
      int E = e;

      const Package* const package = grp->packages[ip];
      if (package->header->resourceIDMap) {
          uint32_t overlayResID = 0x0;
          status_t retval = idmapLookup(package->header->resourceIDMap,
                                        package->header->resourceIDMapSize,
                                        resID, &overlayResID);
          if (retval == NO_ERROR && overlayResID != 0x0) {
              // for this loop iteration, this is the type and entry we really want
              ......
              T = Res_GETTYPE(overlayResID);
              E = Res_GETENTRY(overlayResID);
          } else {
              // resource not present in overlay package, continue with the next package
              continue;
          }
      }

      const ResTable_type* type;
      const ResTable_entry* entry;
      const Type* typeClass;
      //Attention here too!!!!!!!!!!
      ssize_t offset = getEntry(package, T, E, &mParams, &type, &entry, &typeClass);
      if (offset <= 0) {
          // No {entry, appropriate config} pair found in package. If this
          // package is an overlay package (ip != 0), this simply means the
          // overlay package did not specify a default.
          // Non-overlay packages are still required to provide a default.
          if (offset < 0 && ip == 0) {
              ......
              return offset;
          }
          continue;
      }

      if ((dtohs(entry->flags)&entry->FLAG_COMPLEX) != 0) {
          ......
          continue;
      }

      ......

      const Res_value* item =
          (const Res_value*)(((const uint8_t*)type) + offset);
      ResTable_config thisConfig;
      thisConfig.copyFromDtoH(type->config);

      if (outSpecFlags != NULL) {
          if (typeClass->typeSpecFlags != NULL) {
              *outSpecFlags |= dtohl(typeClass->typeSpecFlags[E]);
          } else {
              *outSpecFlags = -1;
          }
      }

      if (bestPackage != NULL &&
          (bestItem.isMoreSpecificThan(thisConfig) || bestItem.diff(thisConfig) == 0)) {
          // Discard thisConfig not only if bestItem is more specific, but also if the two configs
          // are identical (diff == 0), or overlay packages will not take effect.
          continue;
      }

      bestItem = thisConfig;
      bestValue = item;
      bestPackage = package;
  }

  ......

  if (bestValue) {
      outValue->size = dtohs(bestValue->size);
      outValue->res0 = bestValue->res0;
      outValue->dataType = bestValue->dataType;
      outValue->data = dtohl(bestValue->data);
      if (outConfig != NULL) {
          *outConfig = bestItem;
      }
      ......
      return bestPackage->header->index;
  }

  return BAD_VALUE;
}