2012-07-21 12:23:40 +08:00
|
|
|
/****************************************************************************
|
2012-09-04 11:16:59 +08:00
|
|
|
Copyright (c) 2010-2011 cocos2d-x.org
|
|
|
|
Copyright (c) 2011 Zynga Inc.
|
|
|
|
|
|
|
|
http://www.cocos2d-x.org
|
|
|
|
|
|
|
|
Permission is hereby granted, free of charge, to any person obtaining a copy
|
|
|
|
of this software and associated documentation files (the "Software"), to deal
|
|
|
|
in the Software without restriction, including without limitation the rights
|
|
|
|
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
|
|
|
copies of the Software, and to permit persons to whom the Software is
|
|
|
|
furnished to do so, subject to the following conditions:
|
|
|
|
|
|
|
|
The above copyright notice and this permission notice shall be included in
|
|
|
|
all copies or substantial portions of the Software.
|
|
|
|
|
|
|
|
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
|
|
|
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
|
|
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
|
|
|
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
|
|
|
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
|
|
|
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
|
|
|
|
THE SOFTWARE.
|
|
|
|
****************************************************************************/
|
2012-07-21 12:23:40 +08:00
|
|
|
#import <Foundation/Foundation.h>
|
|
|
|
|
|
|
|
#include <string>
|
|
|
|
#include <stack>
|
|
|
|
#include <libxml/parser.h>
|
|
|
|
#include <libxml/tree.h>
|
|
|
|
#include <libxml/xmlmemory.h>
|
|
|
|
#include "CCString.h"
|
|
|
|
#include "CCFileUtils.h"
|
|
|
|
#include "CCDirector.h"
|
2012-07-22 02:46:42 +08:00
|
|
|
#include "CCApplication.h"
|
2012-07-21 12:23:40 +08:00
|
|
|
#include "CCSAXParser.h"
|
|
|
|
#include "CCDictionary.h"
|
2012-07-21 17:19:03 +08:00
|
|
|
#include "support/zip_support/unzip.h"
|
2012-07-21 12:23:40 +08:00
|
|
|
|
|
|
|
#define MAX_PATH 260
|
|
|
|
|
2012-07-21 17:19:03 +08:00
|
|
|
USING_NS_CC;
|
2012-07-21 12:23:40 +08:00
|
|
|
|
|
|
|
static void static_addValueToCCDict(id key, id value, CCDictionary* pDict);
|
2012-07-21 17:19:03 +08:00
|
|
|
static void static_addItemToCCArray(id item, CCArray* pArray);
|
2012-07-21 12:23:40 +08:00
|
|
|
|
|
|
|
static void static_addItemToCCArray(id item, CCArray *pArray)
|
|
|
|
{
|
2012-07-21 17:19:03 +08:00
|
|
|
// add string value into array
|
2012-07-21 12:23:40 +08:00
|
|
|
if ([item isKindOfClass:[NSString class]]) {
|
|
|
|
CCString* pValue = new CCString([item UTF8String]);
|
|
|
|
|
|
|
|
pArray->addObject(pValue);
|
|
|
|
pValue->release();
|
|
|
|
return;
|
|
|
|
}
|
2012-09-04 11:16:59 +08:00
|
|
|
|
2012-07-21 17:19:03 +08:00
|
|
|
// add number value into array(such as int, float, bool and so on)
|
2012-07-21 12:23:40 +08:00
|
|
|
if ([item isKindOfClass:[NSNumber class]]) {
|
|
|
|
NSString* pStr = [item stringValue];
|
|
|
|
CCString* pValue = new CCString([pStr UTF8String]);
|
|
|
|
|
|
|
|
pArray->addObject(pValue);
|
|
|
|
pValue->release();
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
// add dictionary value into array
|
|
|
|
if ([item isKindOfClass:[NSDictionary class]]) {
|
|
|
|
CCDictionary* pDictItem = new CCDictionary();
|
|
|
|
for (id subKey in [item allKeys]) {
|
|
|
|
id subValue = [item objectForKey:subKey];
|
|
|
|
static_addValueToCCDict(subKey, subValue, pDictItem);
|
|
|
|
}
|
|
|
|
pArray->addObject(pDictItem);
|
|
|
|
pDictItem->release();
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
// add array value into array
|
|
|
|
if ([item isKindOfClass:[NSArray class]]) {
|
|
|
|
CCArray *pArrayItem = new CCArray();
|
2012-07-21 17:19:03 +08:00
|
|
|
pArrayItem->init();
|
2012-07-21 12:23:40 +08:00
|
|
|
for (id subItem in item) {
|
|
|
|
static_addItemToCCArray(subItem, pArrayItem);
|
|
|
|
}
|
|
|
|
pArray->addObject(pArrayItem);
|
|
|
|
pArrayItem->release();
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static void static_addValueToCCDict(id key, id value, CCDictionary* pDict)
|
|
|
|
{
|
2012-07-21 17:19:03 +08:00
|
|
|
// the key must be a string
|
2012-07-21 12:23:40 +08:00
|
|
|
CCAssert([key isKindOfClass:[NSString class]], "The key should be a string!");
|
|
|
|
std::string pKey = [key UTF8String];
|
2012-09-04 11:16:59 +08:00
|
|
|
|
2012-07-21 17:19:03 +08:00
|
|
|
// the value is a new dictionary
|
2012-07-21 12:23:40 +08:00
|
|
|
if ([value isKindOfClass:[NSDictionary class]]) {
|
|
|
|
CCDictionary* pSubDict = new CCDictionary();
|
|
|
|
for (id subKey in [value allKeys]) {
|
|
|
|
id subValue = [value objectForKey:subKey];
|
|
|
|
static_addValueToCCDict(subKey, subValue, pSubDict);
|
|
|
|
}
|
2012-07-21 17:19:03 +08:00
|
|
|
pDict->setObject(pSubDict, pKey.c_str());
|
2012-07-21 12:23:40 +08:00
|
|
|
pSubDict->release();
|
|
|
|
return;
|
|
|
|
}
|
2012-09-04 11:16:59 +08:00
|
|
|
|
2012-07-21 17:19:03 +08:00
|
|
|
// the value is a string
|
2012-07-21 12:23:40 +08:00
|
|
|
if ([value isKindOfClass:[NSString class]]) {
|
|
|
|
CCString* pValue = new CCString([value UTF8String]);
|
2012-09-04 11:16:59 +08:00
|
|
|
|
2012-07-21 17:19:03 +08:00
|
|
|
pDict->setObject(pValue, pKey.c_str());
|
2012-07-21 12:23:40 +08:00
|
|
|
pValue->release();
|
|
|
|
return;
|
|
|
|
}
|
2012-09-04 11:16:59 +08:00
|
|
|
|
2012-07-21 17:19:03 +08:00
|
|
|
// the value is a number
|
2012-07-21 12:23:40 +08:00
|
|
|
if ([value isKindOfClass:[NSNumber class]]) {
|
|
|
|
NSString* pStr = [value stringValue];
|
|
|
|
CCString* pValue = new CCString([pStr UTF8String]);
|
|
|
|
|
2012-07-21 17:19:03 +08:00
|
|
|
pDict->setObject(pValue, pKey.c_str());
|
2012-07-21 12:23:40 +08:00
|
|
|
pValue->release();
|
|
|
|
return;
|
|
|
|
}
|
2012-09-04 11:16:59 +08:00
|
|
|
|
2012-07-21 17:19:03 +08:00
|
|
|
// the value is a array
|
2012-07-21 12:23:40 +08:00
|
|
|
if ([value isKindOfClass:[NSArray class]]) {
|
|
|
|
CCArray *pArray = new CCArray();
|
2012-07-21 17:19:03 +08:00
|
|
|
pArray->init();
|
2012-07-21 12:23:40 +08:00
|
|
|
for (id item in value) {
|
|
|
|
static_addItemToCCArray(item, pArray);
|
|
|
|
}
|
2012-07-21 17:19:03 +08:00
|
|
|
pDict->setObject(pArray, pKey.c_str());
|
2012-07-21 12:23:40 +08:00
|
|
|
pArray->release();
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2012-07-21 17:19:03 +08:00
|
|
|
NS_CC_BEGIN
|
2012-07-21 12:23:40 +08:00
|
|
|
|
2012-07-22 02:46:42 +08:00
|
|
|
CCDictionary* ccFileUtils_dictionaryWithContentsOfFileThreadSafe(const char *pFileName);
|
|
|
|
CCArray* ccFileUtils_arrayWithContentsOfFileThreadSafe(const char* pFileName);
|
|
|
|
|
2012-07-21 17:19:03 +08:00
|
|
|
static CCFileUtils* s_pFileUtils = NULL;
|
2013-01-27 20:53:32 +08:00
|
|
|
static std::map<std::string, std::string> s_fullPathCache;
|
2012-07-21 12:23:40 +08:00
|
|
|
|
2012-07-21 17:19:03 +08:00
|
|
|
CCFileUtils* CCFileUtils::sharedFileUtils()
|
|
|
|
{
|
|
|
|
if (s_pFileUtils == NULL)
|
|
|
|
{
|
|
|
|
s_pFileUtils = new CCFileUtils();
|
2013-01-27 20:53:32 +08:00
|
|
|
s_pFileUtils->init();
|
2012-07-21 17:19:03 +08:00
|
|
|
}
|
|
|
|
return s_pFileUtils;
|
|
|
|
}
|
2012-07-21 12:23:40 +08:00
|
|
|
|
2012-07-21 17:19:03 +08:00
|
|
|
void CCFileUtils::purgeFileUtils()
|
|
|
|
{
|
|
|
|
if (s_pFileUtils != NULL)
|
|
|
|
{
|
|
|
|
s_pFileUtils->purgeCachedEntries();
|
2013-01-25 11:12:38 +08:00
|
|
|
CC_SAFE_RELEASE(s_pFileUtils->m_pFilenameLookupDict);
|
2012-07-21 17:19:03 +08:00
|
|
|
}
|
2012-09-04 11:16:59 +08:00
|
|
|
|
2012-07-21 17:19:03 +08:00
|
|
|
CC_SAFE_DELETE(s_pFileUtils);
|
|
|
|
}
|
2012-07-21 12:23:40 +08:00
|
|
|
|
2012-07-21 17:19:03 +08:00
|
|
|
void CCFileUtils::purgeCachedEntries()
|
|
|
|
{
|
2013-01-27 20:53:32 +08:00
|
|
|
s_fullPathCache.clear();
|
2012-07-21 17:19:03 +08:00
|
|
|
}
|
2012-07-21 12:23:40 +08:00
|
|
|
|
2013-01-25 11:12:38 +08:00
|
|
|
bool CCFileUtils::init()
|
|
|
|
{
|
2013-01-27 20:53:32 +08:00
|
|
|
m_searchPathArray.push_back("");
|
|
|
|
m_searchResolutionsOrderArray.push_back("");
|
2013-01-25 11:12:38 +08:00
|
|
|
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2013-01-27 20:53:32 +08:00
|
|
|
void CCFileUtils::setSearchResolutionsOrder(const std::vector<std::string>& searchResolutionsOrder)
|
|
|
|
{
|
|
|
|
m_searchResolutionsOrderArray = searchResolutionsOrder;
|
|
|
|
}
|
|
|
|
|
|
|
|
const std::vector<std::string>& CCFileUtils::getSearchResolutionsOrder()
|
|
|
|
{
|
|
|
|
return m_searchResolutionsOrderArray;
|
|
|
|
}
|
|
|
|
|
|
|
|
void CCFileUtils::setSearchPath(const std::vector<std::string>& searchPaths)
|
|
|
|
{
|
|
|
|
m_searchPathArray = searchPaths;
|
|
|
|
}
|
|
|
|
|
|
|
|
const std::vector<std::string>& CCFileUtils::getSearchPath()
|
|
|
|
{
|
|
|
|
return m_searchPathArray;
|
|
|
|
}
|
|
|
|
|
2012-09-05 16:15:09 +08:00
|
|
|
void CCFileUtils::setResourceDirectory(const char *pszDirectoryName)
|
2012-07-21 17:19:03 +08:00
|
|
|
{
|
2012-08-09 14:34:20 +08:00
|
|
|
m_obDirectory = pszDirectoryName;
|
2012-08-16 10:21:15 +08:00
|
|
|
if (m_obDirectory.size() > 0 && m_obDirectory[m_obDirectory.size() - 1] != '/')
|
|
|
|
{
|
|
|
|
m_obDirectory.append("/");
|
|
|
|
}
|
2013-01-27 20:53:32 +08:00
|
|
|
m_searchPathArray.insert(m_searchPathArray.begin(), m_obDirectory);
|
2013-01-25 11:12:38 +08:00
|
|
|
}
|
|
|
|
|
2013-01-27 20:53:32 +08:00
|
|
|
const char* CCFileUtils::getResourceDirectory()
|
2013-01-25 11:12:38 +08:00
|
|
|
{
|
2013-01-27 20:53:32 +08:00
|
|
|
return m_obDirectory.c_str();
|
2013-01-25 11:12:38 +08:00
|
|
|
}
|
|
|
|
|
2013-01-27 20:53:32 +08:00
|
|
|
const char* CCFileUtils::fullPathFromRelativePath(const char *pszRelativePath)
|
2013-01-25 11:12:38 +08:00
|
|
|
{
|
2013-01-27 20:53:32 +08:00
|
|
|
return CCString::create(fullPathForFilename(pszRelativePath))->getCString();
|
2013-01-25 11:12:38 +08:00
|
|
|
}
|
|
|
|
|
2013-01-27 20:53:32 +08:00
|
|
|
std::string CCFileUtils::getNewFilename(const char* pszFileName)
|
2013-01-25 11:12:38 +08:00
|
|
|
{
|
2013-01-27 20:53:32 +08:00
|
|
|
const char* pszNewFileName = NULL;
|
|
|
|
// in Lookup Filename dictionary ?
|
|
|
|
CCString* fileNameFound = m_pFilenameLookupDict ? (CCString*)m_pFilenameLookupDict->objectForKey(pszFileName) : NULL;
|
|
|
|
if( NULL == fileNameFound || fileNameFound->length() == 0) {
|
|
|
|
pszNewFileName = pszFileName;
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
pszNewFileName = fileNameFound->getCString();
|
|
|
|
}
|
|
|
|
return pszNewFileName;
|
2013-01-25 11:12:38 +08:00
|
|
|
}
|
|
|
|
|
2013-01-27 20:53:32 +08:00
|
|
|
std::string CCFileUtils::getPathForFilename(const std::string& filename, const std::string& resourceDirectory, const std::string& searchPath)
|
2013-01-25 11:12:38 +08:00
|
|
|
{
|
2013-01-27 20:53:32 +08:00
|
|
|
std::string file = filename;
|
|
|
|
std::string file_path = "";
|
|
|
|
size_t pos = filename.find_last_of("/");
|
|
|
|
if (pos != std::string::npos)
|
|
|
|
{
|
|
|
|
file_path = filename.substr(0, pos+1);
|
|
|
|
file = filename.substr(pos+1);
|
|
|
|
}
|
|
|
|
|
|
|
|
// searchPath + file_path + resourceDirectory
|
|
|
|
std::string path = searchPath;
|
|
|
|
if (path[path.length()-1] != '/')
|
|
|
|
{
|
|
|
|
path += "/";
|
|
|
|
}
|
|
|
|
path += file_path;
|
|
|
|
path += resourceDirectory;
|
|
|
|
|
|
|
|
NSString* fullpath = [[NSBundle mainBundle] pathForResource:[NSString stringWithUTF8String:file.c_str()]
|
|
|
|
ofType:nil
|
|
|
|
inDirectory:[NSString stringWithUTF8String:path.c_str()]];
|
|
|
|
|
|
|
|
|
|
|
|
if (fullpath != nil) {
|
|
|
|
return [fullpath UTF8String];
|
|
|
|
}
|
|
|
|
|
|
|
|
// Return empty string when file wasn't found.
|
|
|
|
return "";
|
2012-07-21 17:19:03 +08:00
|
|
|
}
|
|
|
|
|
2013-01-27 20:53:32 +08:00
|
|
|
std::string CCFileUtils::fullPathForFilename(const char* pszFileName)
|
2012-07-21 17:19:03 +08:00
|
|
|
{
|
2013-01-27 20:53:32 +08:00
|
|
|
CCAssert(pszFileName != NULL, "CCFileUtils: Invalid path");
|
2012-08-09 14:34:20 +08:00
|
|
|
|
2013-01-27 20:53:32 +08:00
|
|
|
NSString *relPath = [NSString stringWithUTF8String:pszFileName];
|
2012-08-09 14:34:20 +08:00
|
|
|
|
2013-01-27 20:53:32 +08:00
|
|
|
// Return directly if it's an absolute path.
|
|
|
|
if ([relPath isAbsolutePath]) {
|
|
|
|
return pszFileName;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Already Cached ?
|
|
|
|
std::map<std::string, std::string>::iterator cacheIter = s_fullPathCache.find(pszFileName);
|
|
|
|
if (cacheIter != s_fullPathCache.end()) {
|
|
|
|
//CCLOG("Return full path from cache: %s", cacheIter->second.c_str());
|
|
|
|
return cacheIter->second;
|
|
|
|
}
|
|
|
|
|
|
|
|
std::string fullpath = "";
|
|
|
|
|
|
|
|
// in Lookup Filename dictionary ?
|
|
|
|
std::string newfilename = this->getNewFilename(pszFileName);
|
|
|
|
|
|
|
|
for (std::vector<std::string>::iterator searchPathsIter = m_searchPathArray.begin();
|
|
|
|
searchPathsIter != m_searchPathArray.end(); ++searchPathsIter) {
|
|
|
|
for (std::vector<std::string>::iterator resOrderIter = m_searchResolutionsOrderArray.begin();
|
|
|
|
resOrderIter != m_searchResolutionsOrderArray.end(); ++resOrderIter) {
|
|
|
|
|
|
|
|
fullpath = this->getPathForFilename(newfilename, *resOrderIter, *searchPathsIter);
|
|
|
|
|
|
|
|
if (fullpath.length() > 0)
|
2012-09-03 18:05:59 +08:00
|
|
|
{
|
2013-01-27 20:53:32 +08:00
|
|
|
// Adding the full path to cache if the file was found.
|
|
|
|
s_fullPathCache.insert(std::pair<std::string, std::string>(pszFileName, fullpath));
|
|
|
|
return fullpath;
|
2012-09-03 18:05:59 +08:00
|
|
|
}
|
|
|
|
}
|
2012-07-21 12:23:40 +08:00
|
|
|
}
|
2012-08-09 14:34:20 +08:00
|
|
|
|
2013-01-27 20:53:32 +08:00
|
|
|
// The file wasn't found, return the file name passed in.
|
|
|
|
return pszFileName;
|
|
|
|
}
|
|
|
|
|
|
|
|
void CCFileUtils::loadFilenameLookupDictionaryFromFile(const char* filename)
|
|
|
|
{
|
|
|
|
std::string pFullPath = this->fullPathForFilename(filename);
|
|
|
|
if (pFullPath.length() > 0)
|
2012-07-21 12:23:40 +08:00
|
|
|
{
|
2013-01-27 20:53:32 +08:00
|
|
|
CCDictionary* pDict = CCDictionary::createWithContentsOfFile(filename);
|
|
|
|
if (pDict)
|
|
|
|
{
|
|
|
|
CCDictionary* pMetadata = (CCDictionary*)pDict->objectForKey("metadata");
|
|
|
|
int version = ((CCString*)pMetadata->objectForKey("version"))->intValue();
|
|
|
|
if (version != 1)
|
|
|
|
{
|
|
|
|
CCLOG("cocos2d: ERROR: Invalid filenameLookup dictionary version: %ld. Filename: %s", (long)version, filename);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
setFilenameLookupDictionary((CCDictionary*)pDict->objectForKey("filenames"));
|
|
|
|
}
|
2012-07-21 17:19:03 +08:00
|
|
|
}
|
|
|
|
}
|
2012-07-21 12:23:40 +08:00
|
|
|
|
2013-01-27 20:53:32 +08:00
|
|
|
void CCFileUtils::setFilenameLookupDictionary(CCDictionary* pFilenameLookupDict)
|
|
|
|
{
|
|
|
|
CC_SAFE_RELEASE(m_pFilenameLookupDict);
|
|
|
|
m_pFilenameLookupDict = pFilenameLookupDict;
|
|
|
|
CC_SAFE_RETAIN(m_pFilenameLookupDict);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
const char* CCFileUtils::fullPathFromRelativeFile(const char *pszFilename, const char *pszRelativeFile)
|
2012-07-21 17:19:03 +08:00
|
|
|
{
|
2013-01-27 20:53:32 +08:00
|
|
|
std::string relativeFile = fullPathForFilename(pszRelativeFile);
|
|
|
|
CCString *pRet = CCString::create("");
|
2012-07-21 17:19:03 +08:00
|
|
|
pRet->m_sString = relativeFile.substr(0, relativeFile.rfind('/')+1);
|
2013-01-27 20:53:32 +08:00
|
|
|
pRet->m_sString += getNewFilename(pszFilename);
|
2012-07-21 17:19:03 +08:00
|
|
|
return pRet->m_sString.c_str();
|
|
|
|
}
|
2012-07-21 12:23:40 +08:00
|
|
|
|
2012-07-21 17:19:03 +08:00
|
|
|
CCDictionary* ccFileUtils_dictionaryWithContentsOfFileThreadSafe(const char *pFileName)
|
|
|
|
{
|
2013-01-27 20:53:32 +08:00
|
|
|
std::string fullPath = CCFileUtils::sharedFileUtils()->fullPathForFilename(pFileName);
|
|
|
|
NSString* pPath = [NSString stringWithUTF8String:fullPath.c_str()];
|
2012-07-21 17:19:03 +08:00
|
|
|
NSDictionary* pDict = [NSDictionary dictionaryWithContentsOfFile:pPath];
|
|
|
|
|
|
|
|
CCDictionary* pRet = new CCDictionary();
|
|
|
|
for (id key in [pDict allKeys]) {
|
|
|
|
id value = [pDict objectForKey:key];
|
|
|
|
static_addValueToCCDict(key, value, pRet);
|
2012-07-21 12:23:40 +08:00
|
|
|
}
|
2012-07-21 17:19:03 +08:00
|
|
|
|
|
|
|
return pRet;
|
|
|
|
}
|
2012-07-21 12:23:40 +08:00
|
|
|
|
2012-07-21 17:19:03 +08:00
|
|
|
CCArray* ccFileUtils_arrayWithContentsOfFileThreadSafe(const char* pFileName)
|
|
|
|
{
|
|
|
|
NSString* pPath = [NSString stringWithUTF8String:pFileName];
|
|
|
|
NSString* pathExtension= [pPath pathExtension];
|
|
|
|
pPath = [pPath stringByDeletingPathExtension];
|
|
|
|
pPath = [[NSBundle mainBundle] pathForResource:pPath ofType:pathExtension];
|
|
|
|
NSArray* pArray = [NSArray arrayWithContentsOfFile:pPath];
|
|
|
|
|
|
|
|
CCArray* pRet = new CCArray();
|
|
|
|
for (id value in pArray) {
|
|
|
|
static_addItemToCCArray(value, pRet);
|
2012-07-21 12:23:40 +08:00
|
|
|
}
|
2012-09-04 11:16:59 +08:00
|
|
|
|
2012-07-21 17:19:03 +08:00
|
|
|
return pRet;
|
|
|
|
}
|
2012-07-21 12:23:40 +08:00
|
|
|
|
2012-07-21 17:19:03 +08:00
|
|
|
unsigned char* CCFileUtils::getFileData(const char* pszFileName, const char* pszMode, unsigned long * pSize)
|
|
|
|
{
|
|
|
|
unsigned char * pBuffer = NULL;
|
|
|
|
CCAssert(pszFileName != NULL && pSize != NULL && pszMode != NULL, "Invaild parameters.");
|
|
|
|
*pSize = 0;
|
2012-09-04 11:16:59 +08:00
|
|
|
do
|
2012-07-21 12:23:40 +08:00
|
|
|
{
|
2012-07-21 17:19:03 +08:00
|
|
|
// read the file from hardware
|
|
|
|
FILE *fp = fopen(pszFileName, pszMode);
|
|
|
|
CC_BREAK_IF(!fp);
|
2012-09-04 11:16:59 +08:00
|
|
|
|
2012-07-21 17:19:03 +08:00
|
|
|
fseek(fp,0,SEEK_END);
|
|
|
|
*pSize = ftell(fp);
|
|
|
|
fseek(fp,0,SEEK_SET);
|
|
|
|
pBuffer = new unsigned char[*pSize];
|
|
|
|
*pSize = fread(pBuffer,sizeof(unsigned char), *pSize,fp);
|
|
|
|
fclose(fp);
|
|
|
|
} while (0);
|
2012-09-04 11:16:59 +08:00
|
|
|
|
|
|
|
if (! pBuffer && isPopupNotify())
|
2012-07-21 12:23:40 +08:00
|
|
|
{
|
2012-07-21 17:19:03 +08:00
|
|
|
std::string title = "Notification";
|
|
|
|
std::string msg = "Get data from file(";
|
|
|
|
msg.append(pszFileName).append(") failed!");
|
2012-09-04 11:16:59 +08:00
|
|
|
|
2012-07-21 17:19:03 +08:00
|
|
|
CCMessageBox(msg.c_str(), title.c_str());
|
2012-07-21 12:23:40 +08:00
|
|
|
}
|
2012-07-21 17:19:03 +08:00
|
|
|
return pBuffer;
|
|
|
|
}
|
|
|
|
|
|
|
|
// notification support when getFileData from a invalid file
|
|
|
|
static bool s_bPopupNotify = true;
|
|
|
|
|
|
|
|
void CCFileUtils::setPopupNotify(bool bNotify)
|
|
|
|
{
|
|
|
|
s_bPopupNotify = bNotify;
|
|
|
|
}
|
|
|
|
|
|
|
|
bool CCFileUtils::isPopupNotify()
|
|
|
|
{
|
|
|
|
return s_bPopupNotify;
|
|
|
|
}
|
|
|
|
|
|
|
|
std::string CCFileUtils::getWriteablePath()
|
|
|
|
{
|
|
|
|
// save to document folder
|
|
|
|
NSArray *paths = NSSearchPathForDirectoriesInDomains(NSDocumentDirectory, NSUserDomainMask, YES);
|
|
|
|
NSString *documentsDirectory = [paths objectAtIndex:0];
|
|
|
|
std::string strRet = [documentsDirectory UTF8String];
|
|
|
|
strRet.append("/");
|
|
|
|
return strRet;
|
|
|
|
}
|
|
|
|
|
|
|
|
unsigned char* CCFileUtils::getFileDataFromZip(const char* pszZipFilePath, const char* pszFileName, unsigned long * pSize)
|
|
|
|
{
|
2012-09-04 11:16:59 +08:00
|
|
|
unsigned char * pBuffer = NULL;
|
|
|
|
unzFile pFile = NULL;
|
|
|
|
*pSize = 0;
|
2012-07-21 17:19:03 +08:00
|
|
|
|
2012-09-04 11:16:59 +08:00
|
|
|
do
|
|
|
|
{
|
|
|
|
CC_BREAK_IF(!pszZipFilePath || !pszFileName);
|
|
|
|
CC_BREAK_IF(strlen(pszZipFilePath) == 0);
|
|
|
|
|
|
|
|
pFile = unzOpen(pszZipFilePath);
|
|
|
|
CC_BREAK_IF(!pFile);
|
|
|
|
|
|
|
|
int nRet = unzLocateFile(pFile, pszFileName, 1);
|
|
|
|
CC_BREAK_IF(UNZ_OK != nRet);
|
|
|
|
|
|
|
|
char szFilePathA[260];
|
|
|
|
unz_file_info FileInfo;
|
|
|
|
nRet = unzGetCurrentFileInfo(pFile, &FileInfo, szFilePathA, sizeof(szFilePathA), NULL, 0, NULL, 0);
|
|
|
|
CC_BREAK_IF(UNZ_OK != nRet);
|
|
|
|
|
|
|
|
nRet = unzOpenCurrentFile(pFile);
|
|
|
|
CC_BREAK_IF(UNZ_OK != nRet);
|
|
|
|
|
|
|
|
pBuffer = new unsigned char[FileInfo.uncompressed_size];
|
|
|
|
int nSize = 0;
|
|
|
|
nSize = unzReadCurrentFile(pFile, pBuffer, FileInfo.uncompressed_size);
|
|
|
|
CCAssert(nSize == 0 || nSize == (int)FileInfo.uncompressed_size, "the file size is wrong");
|
|
|
|
|
|
|
|
*pSize = FileInfo.uncompressed_size;
|
|
|
|
unzCloseCurrentFile(pFile);
|
|
|
|
} while (0);
|
2012-07-21 17:19:03 +08:00
|
|
|
|
2012-09-04 11:16:59 +08:00
|
|
|
if (pFile)
|
|
|
|
{
|
|
|
|
unzClose(pFile);
|
|
|
|
}
|
2012-07-21 17:19:03 +08:00
|
|
|
|
2012-09-04 11:16:59 +08:00
|
|
|
return pBuffer;
|
2012-07-21 17:19:03 +08:00
|
|
|
}
|
2012-07-21 12:23:40 +08:00
|
|
|
|
2012-07-21 17:19:03 +08:00
|
|
|
NS_CC_END
|
2012-07-21 12:23:40 +08:00
|
|
|
|