自学教程：C++ AAsset_read函数代码示例

	void ReadFileAsset(const tstring & path, star::SerializedData & data)	{		auto app = star::StarEngine::GetInstance()->GetAndroidApp();		auto manager = app->activity->assetManager;		AAsset* asset = AAssetManager_open(				manager,				star::string_cast<sstring>(path.c_str()).c_str(),				AASSET_MODE_UNKNOWN				);		star::Logger::GetInstance()->Log(asset != NULL,			_T("Couldn't find '") + path + _T("'."));		data.size = AAsset_getLength(asset);		data.data = new schar[sizeof(schar) * data.size];		AAsset_read(asset, data.data, data.size);		AAsset_close(asset);	}

bool FileReader::read(unsigned int count, void*buffer){	writeLog("%d %x %x", count, buffer, asset);	if(asset != nullptr)	{		writeLog("not null or sumthin");		if(AAsset_read(asset, buffer,count) >=0)		{			writeLog("everything went better than expedition");			return true;		}	}	writeLog("Null asset");	return false;}

size_t FileInput::read(unsigned char *buffer, size_t size){	if(!m_asset || !buffer)	{		Console::Print(Console::Error, "Could not read from file.");		return 0;	}	DEBUGPRINT("Reading %i bytes from asset %x", size, m_asset);	int returnval = AAsset_read(m_asset, buffer, size);	DEBUGPRINT("AAsset_read returned %i", returnval);	return returnval;}

char* Renderer::LoadKernelFromAssets(const string * path){#ifdef PLATFORM_WINDOWS	string prefix = "kernelsPC/";#else	string prefix = "kernels/";#endif	string suffix = ".glsl";	string fPath = prefix + *path + suffix;#ifdef PLATFORM_WINDOWS	fPath = Renderer::GetInstance()->ASSET_PATH + fPath;	string sCode;	ifstream vertexShaderStream(fPath.c_str(), ios::in);	if (vertexShaderStream.is_open())	{		string Line = "";		while (getline(vertexShaderStream, Line))		{			sCode += "/n" + Line;		}		vertexShaderStream.close();	}	int length = sCode.length();	char* ret = new char[length + 1];	strcpy(ret, sCode.c_str());	ret[length] = '/0';	return ret;#else	AAssetManager* mgr = System::GetInstance()->GetEngineData()->app->activity->assetManager;	AAsset* shaderAsset = AAssetManager_open(mgr, fPath.c_str(), AASSET_MODE_UNKNOWN);	unsigned int length = AAsset_getLength(shaderAsset);	char * code = new char[length + 1];	AAsset_read(shaderAsset, (void*)code, length);	code[length] = '/0';	return code;#endif}

WRes File_Read(CSzFile *p, void *data, size_t *size){  size_t originalSize = *size;  if (originalSize == 0)    return 0;  #ifdef USE_WINDOWS_FILE  *size = 0;  do  {    DWORD curSize = (originalSize > kChunkSizeMax) ? kChunkSizeMax : (DWORD)originalSize;    DWORD processed = 0;    BOOL res = ReadFile(p->handle, data, curSize, &processed, NULL);    data = (void *)((Byte *)data + processed);    originalSize -= processed;    *size += processed;    if (!res)      return GetLastError();    if (processed == 0)      break;  }  while (originalSize > 0);  return 0;  #else  if(p->mgr)  {	  msg_Dbg("file read");#ifndef ANDROID22	  if(p->asset)		  *size = AAsset_read(p->asset,data,originalSize);#endif	  if (*size == originalSize)		return 0;	  return -1;  }  else  {	  *size = fread(data, 1, originalSize, p->file);	  if (*size == originalSize)		return 0;	  return ferror(p->file);  }  #endif}

bool JniJSModulesUnbundle::isUnbundle(    AAssetManager *assetManager,    const std::string& assetName) {  if (!assetManager) {    return false;  }  auto magicFileName = jsModulesDir(assetName) + MAGIC_FILE_NAME;  auto asset = openAsset(assetManager, magicFileName.c_str());  if (asset == nullptr) {    return false;  }  magic_number_t fileHeader = 0;  AAsset_read(asset.get(), &fileHeader, sizeof(fileHeader));  return fileHeader == htole32(MAGIC_FILE_HEADER);}

///// esFileRead()////    Wrapper for platform specific File read//static size_t esFileRead ( esFile *pFile, int bytesToRead, void *buffer ){   size_t bytesRead = 0;   if ( pFile == NULL )   {      return bytesRead;   }#ifdef ANDROID   bytesRead = AAsset_read ( pFile, buffer, bytesToRead );#else   bytesRead = fread ( buffer, bytesToRead, 1, pFile );#endif   return bytesRead;}

	/** 	* Load a scene from a supported 3D file format	*	* @param filename Name of the file (or asset) to load	* @param flags (Optional) Set of ASSIMP processing flags	*	* @return Returns true if the scene has been loaded	*/	bool LoadMesh(const std::string& filename, int flags = defaultFlags)	{#if defined(__ANDROID__)		// Meshes are stored inside the apk on Android (compressed)		// So they need to be loaded via the asset manager		AAsset* asset = AAssetManager_open(assetManager, filename.c_str(), AASSET_MODE_STREAMING);		assert(asset);		size_t size = AAsset_getLength(asset);		assert(size > 0);				void *meshData = malloc(size);		AAsset_read(asset, meshData, size);		AAsset_close(asset);		pScene = Importer.ReadFileFromMemory(meshData, size, flags);		free(meshData);#else		pScene = Importer.ReadFile(filename.c_str(), flags);#endif		if (pScene)		{			m_Entries.clear();			m_Entries.resize(pScene->mNumMeshes);			// Read in all meshes in the scene			for (auto i = 0; i < m_Entries.size(); i++)			{				m_Entries[i].vertexBase = numVertices;				numVertices += pScene->mMeshes[i]->mNumVertices;				const aiMesh* paiMesh = pScene->mMeshes[i];				InitMesh(&m_Entries[i], paiMesh, pScene);			}			return true;		}		else 		{			printf("Error parsing '%s': '%s'/n", filename.c_str(), Importer.GetErrorString());#if defined(__ANDROID__)			LOGE("Error parsing '%s': '%s'", filename.c_str(), Importer.GetErrorString());#endif			return false;		}	}

bool androidExtractAll() {	AAssetDir* assetDir = AAssetManager_openDir(gActivity->assetManager, "");	const char* filename = (const char*)NULL;	std::string assetContent;	while ((filename = AAssetDir_getNextFileName(assetDir)) != NULL) {		std::string newPath = androidGetPath(filename);		AAsset* asset = AAssetManager_open(gActivity->assetManager, filename,		                                   AASSET_MODE_STREAMING);		FLOG_DEBUG("File %s opened for extraction ...", filename );		// Find size		off_t assetSize = AAsset_getLength(asset);		// Prepare input buffer		assetContent.resize(assetSize);		// Store input buffer		AAsset_read(asset, &assetContent[0], assetSize);		// Close		AAsset_close(asset);		// Check if file exists		std::ifstream f(newPath.c_str());		if (f.good()) {			f.close();			FLOG_DEBUG("Asset %s already extracted", filename);		} else {			// Prepare output buffer			std::ofstream assetExtracted(newPath.c_str(),			                             std::ios::out | std::ios::binary);			if (!assetExtracted) {				FLOG_ERROR("File %s not extracted", newPath.c_str());				return false;			}			// Write output buffer into a file			assetExtracted.write(assetContent.c_str(), assetSize);			assetExtracted.close();			FLOG_DEBUG("File %s extracted", filename);		}	}	return true;	AAssetDir_close(assetDir);}

bool loadCompressedTexture(GLenum target, int level, GLenum internalFormat, int width,                           int height, const std::string& fileName){#if defined(SUPPORT_ANDROID)    AAsset* asset = AAssetManager_open(ctx.assetManager, fileName.c_str(), O_RDONLY);    if (!asset)    {        LOGW("Unable to open asset %s", fileName.c_str());        return false;    }    off_t size = AAsset_getLength(asset);    void* pixels = malloc(size);    AAsset_read(asset, pixels, size);    AAsset_close(asset);#else // !SUPPORT_ANDROID    int fd = open(fileName.c_str(), O_RDONLY);     if (fd == -1)    {        perror("open");        return false;    }    struct stat sb;    if (fstat(fd, &sb) == -1)    {        perror("stat");        return false;    }    off_t size = sb.st_size;    void* pixels = mmap(NULL, size, PROT_READ, MAP_PRIVATE, fd, 0);#endif // !SUPPORT_ANDROID    glCompressedTexImage2D(target, level, internalFormat, width, height, 0, size, pixels);#if defined(SUPPORT_ANDROID)    free(pixels);#else    munmap(pixels, sb.st_size);    close(fd);#endif    ASSERT_GL();    return true;}

bool androidExtract( const std::string& name ) {	const char* pFile = name.c_str();	std::string newPath = androidGetPath(pFile);	AAssetDir* a;	if ( androidExtracted(name.c_str()) ) {		FLOG_DEBUG("File %s already extracted", name.c_str());		return true;	}	AAsset* asset = AAssetManager_open(gActivity->assetManager, name.c_str(),	                                   AASSET_MODE_STREAMING);	std::string assetContent;	if (asset != NULL) {		// Find size		off_t assetSize = AAsset_getLength(asset);		// Prepare input buffer		assetContent.resize(assetSize);		// Store input buffer		AAsset_read(asset, &assetContent[0], assetSize);		// Close		AAsset_close(asset);		// Prepare output buffer		std::ofstream assetExtracted(newPath.c_str(),		                             std::ios::out | std::ios::binary);		if (!assetExtracted) {			FLOG_ERROR("File %s not extracted", newPath.c_str());			return false;		}		// Write output buffer into a file		assetExtracted.write(assetContent.c_str(), assetSize);		assetExtracted.close();		FLOG_DEBUG("File extracted");		return true;	} else {		FLOG_ERROR("File %s not extracted. Returning empty string", name.c_str());		return false;	}}

    bool CFileSystem::ReadFile(Handle file, void* pBuffer, uint32_t nNumberOfBytesToRead, uint32_t* pNumberOfBytesRead) {        if (!file) {            BEHAVIAC_LOGERROR("File not open");            return 0;        }#if BEHAVIAC_CCDEFINE_ANDROID && (BEHAVIAC_CCDEFINE_ANDROID_VER > 8)        size_t ret = AAsset_read((AAsset*)file, pBuffer, nNumberOfBytesToRead);#else        size_t ret = fread(pBuffer, 1, nNumberOfBytesToRead, (FILE*)file);#endif        if (pNumberOfBytesRead) {            *pNumberOfBytesRead = ret;        }        return true;    }

GLubyte* FileReader::loadTGA(const std::string &fileName, tgaHeader &header){	AAsset* asset = AAssetManager_open(FileReader::manager, fileName.c_str(), AASSET_MODE_UNKNOWN);	if(asset == NULL)	{		writeLog("Asset = NULL");	}    AAsset_read(asset, &header.idLength, 1);    AAsset_read(asset, &header.colorMapType, 1);    AAsset_read(asset, &header.type, 1);    AAsset_seek(asset, 9, SEEK_CUR);    AAsset_read(asset, &header.width, 2);    AAsset_read(asset, &header.height, 2);    AAsset_read(asset, &header.depth, 1);    AAsset_read(asset, &header.descriptor, 1);    AAsset_seek(asset, header.idLength, SEEK_CUR);    	//writeLog("spritewidth: %d, height: %d, depth: %d", header.width, header.height, header.depth);    //24bit / 8 = 3 (RGB), 32bit / 8 = 4 (RGBA)    int componentCount = header.depth/8;        int size = componentCount * header.width * header.height;    GLubyte* data = new GLubyte[size];        AAsset_read(asset, data, size);        //data is now BGRA so we format it to RGBA    for(int i = 0; i < size; i += componentCount)    {        GLubyte temp = data[i];                //Switch red and blue        data[i] = data[i+2];        data[i+2] = temp;    }        AAsset_close(asset);	return data;}

char *VSShaderLib::textFileRead(std::string fileName) {	char *content = NULL;#ifndef __ANDROID_API__	FILE *fp;	size_t count=0;	if (fileName != "") {		fp = fopen(fileName.c_str(),"rt");		if (fp != NULL) {      			fseek(fp, 0, SEEK_END);			count = ftell(fp);			rewind(fp);			if (count > 0) {				content = (char *)malloc(sizeof(char) * (count+1));				count = fread(content, sizeof(char), count, fp);				content[count] = '/0';			}			fclose(fp);		}	}	return content;#else	AAsset* asset = AAssetManager_open(s_AssetManager, fileName.c_str(), AASSET_MODE_UNKNOWN);	const char *loc = "VSShaderLib::readText";	if (NULL == asset) {		__android_log_print(ANDROID_LOG_ERROR, loc, "%s", "_ASSET_NOT_FOUND_");		return content;	}	size_t size = (size_t)AAsset_getLength(asset);	content = (char*)malloc(sizeof(char)*size + 1);	AAsset_read(asset, content, size);	content[size] = '/0';	__android_log_print(ANDROID_LOG_DEBUG, loc, "%s", content);	AAsset_close(asset);	return content;#endif}

FileUtils::FileData FileUtils::getFileData(const char* fileName){	DebugLog::print( "FileUtils::getFileData(%s)", fileName );	AAsset* asset = AAssetManager_open(g_aassetManager, (const char *) fileName, AASSET_MODE_UNKNOWN);    if (NULL == asset) {        DebugLog::print("Failed !");        return FileData();    }    long size = AAsset_getLength(asset);    FileData res = findFreeFileDataSlot(size);	    res.size = size;        AAsset_read (asset, res.bytes, size);    AAsset_close(asset);	    return res;}

void androidReadToString(const char* pFileName, std::string& fileContent) {	assert( gActivity->assetManager );	AAsset* pFile = AAssetManager_open(gActivity->assetManager, pFileName,	                                   AASSET_MODE_UNKNOWN);	if (pFile != NULL) {		off_t fileSize = AAsset_getLength(pFile);		fileContent.resize(fileSize);		char* pData = new char[fileSize];		AAsset_read(pFile, &fileContent[0], fileSize);		AAsset_close(pFile);		FLOG_DEBUG("File %s found", pFileName);	} else {		FLOG_ERROR("File %s not found", pFileName);	}}

/* * For native implementation for java methods, if it's static method * belongs to class itself, then second parameter should be jclass(it * refers to MocClient here), otherwise, it should be jobject because * it's just instance of specified class. */static jbooleanj_moc_init(JNIEnv *env, jobject obj,        jobject assetManager, jstring fileStr){    char *fileChars = NULL;    if (fileStr) {        fileChars = (char*) (*env)->GetStringUTFChars(env, fileStr, NULL);        LOGI("moc client would to be initialized by file %s.", fileChars);    } else {        fileChars = "conf/mocclient.hdf";        LOGI("moc client would to be initialized by default configurations.");    }    AAssetManager *manager = AAssetManager_fromJava(env, assetManager);    assert(manager != NULL);    AAsset *file = AAssetManager_open(manager, "conf/mocclient.hdf", AASSET_MODE_UNKNOWN);    if (file == NULL) {        LOGE("sepecified file does not exists in apk.");    }    /* read contents from config file */    off_t bufferSize = AAsset_getLength(file);    char *buffer     = (char*) malloc(bufferSize + 1);    buffer[bufferSize] = 0;    AAsset_read(file, buffer, bufferSize);    /* close file */    AAsset_close(file);     moc_init_frombuf(buffer);    /*     * initial module calback hash table     * but it only supports bang module currently     */    hash_init(&registed_callback_module_table, hash_str_hash, hash_str_comp, NULL);    hash_insert(registed_callback_module_table, (void*) "bang", (void*) j_moc_regist_callback_bang);    return true;}

int FileAccessAndroid::get_buffer(uint8_t *p_dst, int p_length) const {	off_t r = AAsset_read(a,p_dst,p_length);	if (pos+p_length >len ) {		eof=true;	}	if (r>=0) {		pos+=r;		if (pos>len) {			pos=len;		}	}	return r;}

std::string gg::Util::loadFile(const std::string &fileName){	//TODO: check for invalid filenames	AAsset* asset = AAssetManager_open(gg::AssetManager::manager, fileName.c_str(), AASSET_MODE_UNKNOWN);	off_t length = AAsset_getLength(asset);	char* text = new char[length+1];	if(AAsset_read(asset, text, length) < 1)	{		writeLog("File not loaded! Error! Error!");	}	text[length] = 0;	AAsset_close(asset);	text[length] = 0;	std::string r(text);	return r;}

static void* LoadFileFunc(const char* pFilename, char** pData, size_t &size){	size = 0;	AAsset* pAsset = AAssetManager_open(g_AssetManager, pFilename, AASSET_MODE_BUFFER);	if(pAsset)	{		off_t length = AAsset_getLength(pAsset);		if(length)		{			SHandle *pHandle = new SHandle();			if(pHandle)			{				pHandle->size = length;				pHandle->pData = new char[length];				if(pHandle->pData)				{					if(length == AAsset_read(pAsset, pHandle->pData, length))					{						AAsset_close(pAsset);						size = length;						*pData = pHandle->pData;						return pHandle;					}					delete[] pHandle->pData;				}				delete pHandle;			}		}		AAsset_close(pAsset);	}	return 0;}

static void assetReadSync(JXValue *results, int argc) {  char *filename = JX_GetString(&results[0]);  AAsset *asset =      AAssetManager_open(assetManager, filename, AASSET_MODE_UNKNOWN);  free(filename);  if (asset) {    off_t fileSize = AAsset_getLength(asset);    void *data = malloc(fileSize);    int read_len = AAsset_read(asset, data, fileSize);    JX_SetBuffer(&results[argc], (char *)data, read_len);    free(data);    AAsset_close(asset);    return;  }  const char *err = "File doesn't exist";  JX_SetError(&results[argc], err, strlen(err));}

char* _spUtil_readFile (const char* path, int* length) {	AAssetManager* assetManager = (AAssetManager*) get_asset_manager();	AAsset* asset = AAssetManager_open(assetManager, (const char *) path, AASSET_MODE_UNKNOWN);	if (NULL == asset) {		__android_log_print(ANDROID_LOG_ERROR, "SpineAndroid", "Asset (%s) not found", path);		return NULL;	}	long size = AAsset_getLength(asset);	*length = size;	char* buffer = (char*) malloc (sizeof(char)*size);	AAsset_read (asset,buffer,size);	AAsset_close(asset);	return buffer;}

int ReadStringAM(AAsset* asset, char * buffer, int count, int offset) {	AAsset_seek(asset, offset, SEEK_SET);	int r_count = AAsset_read(asset, buffer, count);	if (r_count <= 0)		return r_count;	for (int i = 0; i < r_count; ++i) {		if (buffer[i] == '/n') {			buffer[i] = '/0';			AAsset_seek(asset, offset + i + 1, SEEK_SET);			return offset + i + 1;		}	}	if (count == r_count && buffer[r_count - 1] != '/n')		return 0;	return offset + r_count + 1;}

std::string ResourceEngineAndroid::loadLevel(std::string const& levelName) {	//logging::Fatal() << " not implemented";	if (!assertAssetManager())		return "";	const std::string fileName(getLevelPrefix() + levelName + ".xml");	AAsset * asset = AAssetManager_open(m_assetManager, fileName.c_str(),			AASSET_MODE_STREAMING);	if (asset == nullptr) {		logging::Fatal() << "Asset with name " << fileName				<< " could not be loaded.";		return "";	}	constexpr size_t buffer_size = 1024;	int bytes_read;	char buffer[buffer_size];	std::string textFileString;	while (true) {		bytes_read = AAsset_read(asset, &buffer, buffer_size);		if (bytes_read < 0) {			logging::Fatal() << "Error while reading from file " << fileName;			return "";		} else {			std::string bufString(buffer);			bufString.resize(bytes_read);			textFileString.append(bufString);			// at the end !			if (bytes_read < buffer_size)				break;		}	}	logging::Info() << "Completed reading of file " << fileName;	return textFileString;}

///// esFileRead()////    Wrapper for platform specific File read//static int esFileRead ( void * ioContext, void *pFile, int bytesToRead, void *buffer ){    int bytesRead = 0;    if ( pFile == NULL )    {        return bytesRead;    }    LOGE("bytesToRead is %d", bytesToRead);    if (ioContext != NULL)    {        bytesRead = AAsset_read ( pFile, buffer, bytesToRead );    }    else    {        bytesRead = fread ( buffer, bytesToRead, 1, pFile );    }    return bytesRead;}

//--------------------------------------------------------------------------VeAssetPath::ReadTask::ReadTask(const VeChar8* pcFullPath,	VeRefNode<ReadCallback>& kCallback) noexcept	: m_kFullPath(pcFullPath){	IncRefCount();	m_kNode.m_Content = this;	ve_sys.Collect(m_kNode);	m_kCallback.attach_back(kCallback);	m_kTask.m_Content = [this](VeTaskQueue& kMgr) noexcept	{		AAsset* pkAsset = AAssetManager_open(s_pkAssetManager,			m_kFullPath, AASSET_MODE_UNKNOWN);		if (pkAsset)		{			VeInt32 i32Len = AAsset_getLength(pkAsset);			if (i32Len)			{				VeBlobPtr spBlob = VE_NEW VeBlob(i32Len);				VeInt32 i32Read = AAsset_read(pkAsset,					spBlob->GetBuffer(), i32Len);				if (i32Read == i32Len)				{					m_spData = VE_NEW VeMemoryIStream(spBlob);				}			}			AAsset_close(pkAsset);		}		m_kTask.m_Content = [this](VeTaskQueue& kMgr) noexcept		{			for (auto call : m_kCallback)			{				call(m_spData);			}			DecRefCount();		};		kMgr.AddFGTask(m_kTask);	};	ve_res_mgr.GetTaskQueue(VeResourceManager::TASK_FILE).AddBGTask(m_kTask);}

s32 FileAsset::readBuffer(void* Buffer, u32 Size, u32 Count) const{    /* Check for valid data */    if (!Buffer || !Size || !Count || !opened())        return 0;        /* Read buffer out of file */    s32 Result = AAsset_read(Asset_, Buffer, Size * Count);        /* Check for errors */    if (Result < 0)    {        Log::error("Could not read buffer out of asset");        return -1;    }        /* Boost seek position */    Pos_ += Result;        /* Return count of read bytes */    return Result;}

/******************************************************************** * Test for asset *******************************************************************/void test_apk(struct android_app* state){    AAssetManager* mgr = state->activity->assetManager;    AAsset* asset = AAssetManager_open(mgr,                                       "fuck.txt", AASSET_MODE_UNKNOWN);    if(asset == NULL)    {        LOGI("assets == NULL");    }    off_t size = AAsset_getLength(asset);    LOGI("size=%d",size);    char* buffer = new char[size+1];    buffer[size] = 0;    int num_read = AAsset_read(asset, buffer, size);    //LOGI(buffer);    AAsset_close(asset);}

int LoadShader(GLuint Shader, char *Filename){	AAsset *stream;	char *buffer;	int length;	if((stream=AAssetManager_open(assetManager, Filename, AASSET_MODE_BUFFER))==NULL)		return 0;	length=AAsset_getLength(stream);	buffer=(char *)malloc(length+1);	AAsset_read(stream, buffer, length);	buffer[length]='/0';	glShaderSource(Shader, 1, (const char **)&buffer, &length);	AAsset_close(stream);	free(buffer);	return 1;}