1. #1
    Sencha User
    Join Date
    Mar 2012
    Posts
    65
    Vote Rating
    3
    thang_ibrahim is on a distinguished road

      0  

    Default Unanswered: Problem Utf-8 on sencha sdk 3.0.0.188

    Unanswered: Problem Utf-8 on sencha sdk 3.0.0.188


    I save file in utf-8.
    When i run on device , it didn't show correct character.
    Anybody know this issue

  2. #2
    Sencha User
    Join Date
    Aug 2011
    Posts
    15
    Vote Rating
    1
    raye is on a distinguished road

      0  

    Default


    Me too!! No problems in SDK 2.x with the same code.

  3. #3
    Sencha User
    Join Date
    Mar 2012
    Posts
    65
    Vote Rating
    3
    thang_ibrahim is on a distinguished road

      0  

    Default


    sencha sdk 3.0.0.122 worked on mac osx 10.7 but didn't work on win 7 with character ư ơ
    sencha sdk 3.0.0.188 didn't worked both mac osx and win 7

  4. #4
    Sencha User
    Join Date
    Feb 2012
    Posts
    19
    Vote Rating
    0
    anhnt3 is on a distinguished road

      0  

    Default


    Work around in Windows 7: before type "sencha app build package" in cmd, type "65001"

    It will change local of cmd to unicode, which used by YUI js/css compressor.

    I think sencha.jar should set unicode by default by pass parameterr to YUI compressor

  5. #5
    Sencha Premium Member
    Join Date
    Feb 2012
    Location
    Berne, Switzerland
    Posts
    714
    Answers
    41
    Vote Rating
    42
    ingo.hefti has a spectacular aura about ingo.hefti has a spectacular aura about ingo.hefti has a spectacular aura about

      0  

    Default


    Quote Originally Posted by anhnt3 View Post
    Work around in Windows 7: before type "sencha app build package" in cmd, type "65001"
    Thanks for your hint! However just typing "65001" doesn't work. Anything I miss here?

  6. #6
    Sencha User
    Join Date
    Feb 2012
    Posts
    19
    Vote Rating
    0
    anhnt3 is on a distinguished road

      0  

    Default


    Sorry man,
    chcp 65001

  7. #7
    Sencha Premium Member
    Join Date
    Feb 2012
    Location
    Berne, Switzerland
    Posts
    714
    Answers
    41
    Vote Rating
    42
    ingo.hefti has a spectacular aura about ingo.hefti has a spectacular aura about ingo.hefti has a spectacular aura about

      0  

    Default


    Thanks man - I can switch the code page now.

    However I still have wrong chars in my (newly built) native app - no change...

  8. #8
    Sencha User
    Join Date
    Feb 2012
    Posts
    19
    Vote Rating
    0
    anhnt3 is on a distinguished road

      0  

    Default


    First build using sencha app build package -> check the output, it display unicode character OK.
    Second, i use those output with phonegap (ios and android) -> check the output, it display unicode character OK.

    I do not use sencha command to generate native app.
    Note: I use sencha 2.1 RC1 and sencha cmd3 v190.

  9. #9
    Sencha User
    Join Date
    Apr 2010
    Location
    China
    Posts
    227
    Answers
    64
    Vote Rating
    20
    haduki will become famous soon enough haduki will become famous soon enough

      0  

    Default


    C:\Users\XXXXXXX\bin\Sencha\Cmd\3.0.0.190\plugins\touch\current\app-build.js
    Code:
    importPackage(java.lang);
    importPackage(java.io);
    importPackage(javax.script);
    importPackage(com.sencha.util);
    importPackage(com.sencha.util.filters);
    importPackage(com.sencha.logging);
    importPackage(com.sencha.exceptions);
    importPackage(com.sencha.command);
    importPackage(com.sencha.tools.compressors.yui);
    importPackage(com.sencha.tools.compressors.closure);
    importPackage(com.sencha.tools.external);
    importPackage(com.sencha.tools.compiler.jsb.statements);
    
    
    var _logger = SenchaLogManager.getLogger("app-build");
    
    
    var JSON = new (function () {
        var useHasOwn = !!{}.hasOwnProperty,
            pad = function (n) {
                return n < 10 ? "0" + n : n;
            },
            doDecode = function (json) {
                return eval("(" + json + ')');
            },
            doEncode = function (o) {
                if (typeof o == 'undefined' || o === null) {
                    return "null";
                } else if (Object.prototype.toString.call(o) === '[object Array]') {
                    return encodeArray(o);
                } else if (Object.prototype.toString.call(o) === '[object Date]') {
                    return JSON.encodeDate(o);
                } else if (typeof o == 'string') {
                    return encodeString(o);
                } else if (typeof o == 'number') {
                    //don't use isNumber here, since finite checks happen inside isNumber
                    return isFinite(o) ? String(o) : "null";
                } else if (typeof o == 'boolean') {
                    return String(o);
                } else if (typeof o == 'object') {
                    return encodeObject(o);
                } else if (typeof o === "function") {
                    return encodeString(o.toString());
                }
                return 'undefined';
            },
            m = {
                "\b":'\\b',
                "\t":'\\t',
                "\n":'\\n',
                "\f":'\\f',
                "\r":'\\r',
                '"':'\\"',
                "\\":'\\\\',
                '\x0b':'\\u000b' //ie doesn't handle \v
            },
            charToReplace = /[\\\"\x00-\x1f\x7f-\uffff]/g,
            encodeString = function (s) {
                return '"' + s.replace(charToReplace, function (a) {
                    var c = m[a];
                    return (typeof c === 'string') ? c : ('\\u' + ('0000' + a.charCodeAt(0).toString(16)).slice(-4));
                }) + '"';
            },
            encodeArray = function (o) {
                var a = ["[", ""],
                // Note empty string in case there are no serializable members.
                    len = o.length,
                    i;
                for (i = 0; i < len; i += 1) {
                    a.push(doEncode(o[i]), ',');
                }
                // Overwrite trailing comma (or empty string)
                a[a.length - 1] = ']';
                return a.join("");
            },
            encodeObject = function (o) {
                var a = ["{", ""],
                // Note empty string in case there are no serializable members.
                    i;
                for (i in o) {
                    if (typeof o[i] != 'function' && (!useHasOwn ||( o.hasOwnProperty && o.hasOwnProperty(i)))) {
                        a.push(doEncode(i), ":", doEncode(o[i]), ',');
                    }
                }
                // Overwrite trailing comma (or empty string)
                a[a.length - 1] = '}';
                return a.join("");
            };
    
    
        this.encodeDate = function (o) {
            return '"' + o.getFullYear() + "-"
                + pad(o.getMonth() + 1) + "-"
                + pad(o.getDate()) + "T"
                + pad(o.getHours()) + ":"
                + pad(o.getMinutes()) + ":"
                + pad(o.getSeconds()) + '"';
        };
    
    
        this.encode = doEncode;
        this.decode = doDecode;
    
    
    })();
    
    
    function readConfig(configFile) {
        _logger.trace("reading config data from {}", configFile);
        // ensure the data is a javascript string
        var configData = '' + readFileContent(configFile);
        return jsonDecode(configData);
    }
    
    
    function jsonDecode(data) {
        _logger.trace("decoding json data");
        return JSON.decode(data);
    }
    
    
    function jsonEncode(obj) {
        _logger.debug("encoding json data");
        return JSON.encode(obj);
    }
    
    
    function map(list, func) {
        var out = [],
            len = list.length,
            i;
        for (i = 0; i < len; i++) {
            out.push(func(list[i]));
        }
        return out;
    }
    
    
    function each(list, func) {
        var len = list.length,
            i;
        for (i = 0; i < len; i++) {
            func(list[i]);
        }
        return list;
    }
    
    
    function filter(list, func) {
        var newlist = [],
            len = list.length,
            i, item;
        for (i = 0; i < len; i++) {
            item = list[i];
            if (func(item)) {
                newlist.push(item);
            }
        }
        return newlist;
    }
    
    
    function concat(list1, list2) {
        var newlist = [],
            func = function (item) {
                newlist.push(item);
            };
        each(list1, func);
        each(list2, func);
        return newlist;
    }
    
    
    function resolvePath() {
        return new File(joinPath.apply(this, arguments)).getCanonicalPath();
    }
    
    
    function joinPath() {
        var len = arguments.length, i, paths = [];
        for (i = 0; i < len; i++) {
            if (_logger.isTraceEnabled()) {
                _logger.trace("adding path arg : {}", arguments[i]);
            }
            paths.push(arguments[i]);
        }
        return paths.join(File.separator);
    }
    
    
    function stripSpecialDirNames(path) {
        return path
            .replace("../", "")
            .replace("..\\", "")
            .replace("./", "")
            .replace(".\\", "")
            .replace("~/", "");
    }
    
    
    function readFileContent(file,encode) {
        if(encode){
            var reader=new BufferedReader(new InputStreamReader(new FileInputStream(file),'UTF-8'));
            var s=new StringBuffer();
            var i="";
            while(null!=(i=reader.readLine())){
              s.append(i+"\n");
            }
    
    
            return s.toString();       
        }
        else{
            return FileUtil.readFile(file);
        }
    }
    
    
    function writeFileContent(file, content) {
        FileUtil.writeFile(file, content);
    }
    
    
    function copy(src, dest, filter) {
        if(filter) {
            FileUtil.copy(src, dest, filter);
        } else {
            FileUtil.copy(src, dest);
        }
    }
    
    
    function runAppBuild(proj) {
        var basedir = proj.getProperty("basedir"),
            appPath = proj.getProperty("args.path"),
            envArg = proj.getProperty("args.environment"),
            config = readConfig(resolvePath(appPath, "app.json")),
            environment = (envArg == "native") ? 'package' : envArg,
            destination = proj.getProperty("args.destination") || config.buildPaths[environment],
            v2deps = !!(proj.getProperty("v2deps") == "true"),
            src = appPath,
            sdk = proj.getProperty("framework.dir"),
            archive = proj.getProperty("args.archive") || config.archivePath|| "archive",
            nativePackaging = !!(envArg == 'native'),
            indexHtmlPath = config.indexHtmlPath || 'index.html',
            appUrl = config.url || resolvePath(src, indexHtmlPath),
            jsAssets = config.js || [],
            cssAssets = config.css || [],
            appCache = config.appCache,
            ignore = config.ignore,
            remoteAssets = [],
            extras = config.extras || config.resources,
            appJs, assets, processIndex;
    
    
        destination = joinPath(destination, environment);
    
    
        if (appUrl.indexOf("file:") != 0 && appUrl.indexOf("http:") != 0) {
            appUrl = 'file:///' + StringUtil.replace(resolvePath(appUrl), '\\', '/');
        }
    
    
        // check for build dir being immediate child of application dir
        // native packager can get in to infinite looping when scanning files
        // under this scenario
        var canonicalAppPath = new File(appPath).getCanonicalPath(),
            canonicalDestPath = new File(destination).getCanonicalPath(),
            parent = new File(canonicalDestPath).getParentFile();
    
    
        if(parent && parent.getCanonicalPath() == canonicalAppPath) {
            _logger.error("Application : {}", canonicalAppPath);
            _logger.error("Destination : {}", canonicalDestPath);
            _logger.error("Destination path cannot reside one level under the Application directory")
            throw "Destination path cannot reside one level under the Application directory";
        }
    
    
    
    
        _logger.info("Deploying your application to " + destination);
    
    
        PathUtil.ensurePathExists(resolvePath(destination));
    
    
        jsAssets = each(
            map(jsAssets, function (asset) {
                if (typeof asset == 'string') {
                    asset = { path:asset };
                }
                asset.type = 'js';
                return asset;
            }),
            function (jsAsset) {
                if (jsAsset.bundle) {
                    appJs = jsAsset.path;
                }
            });
    
    
        if (!appJs) {
            appJs = 'app.js';
        }
    
    
        appJs = resolvePath(destination, appJs);
    
    
        cssAssets = map(cssAssets, function (asset) {
            if (typeof asset == 'string') {
                asset = { path:asset };
            }
            asset.type = 'css';
            return asset;
        });
    
    
        assets = filter(concat(jsAssets, cssAssets), function (asset) {
            return !asset.shared || (environment != 'production');
        });
    
    
        _logger.debug("copying all assets");
        each(assets, function (asset) {
            if (asset.remote) {
                asset.bundle = false;
                asset.update = false;
                remoteAssets.push(asset);
            } else {
                file = asset.path;
    
    
                // if not in testing mode, and using the new compiler, and this is
                // one of the sencha-touch files, don't copy to output directory
                if( asset.type === 'js' &&
                    environment != 'testing' &&
                    !v2deps &&
                    file.indexOf("sencha-touch") != -1) {
                    asset.skipFrameworkFile = true;
                    return;
                }
    
    
                _logger.debug("copying file {}", resolvePath(src, file));
    
    
                PathUtil.ensurePathExists(joinPath(destination, file));
    
    
                var srcPath = resolvePath(src, file),
                    dstPath = resolvePath(destination, file);
    
    
                if(srcPath != dstPath) {
                    copy(resolvePath(src, file), resolvePath(destination, file));
    
    
                    _logger.info("Copied {}", file);
                }
            }
        });
    
    
        var ignoreFilter = Filter.getFileNameFilter(
            new RegexFilter(ignore).setInclusive(false));
    
    
        _logger.debug("copying all extras");
        each(extras, function (extra) {
            var from = resolvePath(src, extra),
                to = resolvePath(destination, extra);
            _logger.debug("copying from {} to {}", from, to);
            if (new File(from).exists()) {
                copy(from, to, ignoreFilter);
                _logger.info("Copied {}", from);
            }
        });
    
    
        // build the app
    
    
        processIndex = function () {
            _logger.debug("processing page : index.html");
            jsAssets = filter(jsAssets, function(asset){
                return !asset.skipFrameworkFile;
            });
    
    
            var appJson = jsonEncode({
                    id:config.id,
                    js:jsAssets,
                    css:cssAssets
                }),
                indexHtml, content, compressor, remotes, microloader;
    
    
            writeFileContent(new File(destination, 'app.json'), appJson);
            _logger.info("Generated app.json");
    
    
            indexHtml = readFileContent(new File(src, indexHtmlPath));
    
    
            if (environment == 'production' && appCache) {
                indexHtml = StringUtil.replace(
                    indexHtml,
                    '<html manifest=""',
                    '<html manifest="cache.appcache"');
            }
    
    
            compressor = new ClosureCompressor();
            microloader = (environment == 'production'
                ? 'production'
                : 'testing') +
                '.js';
            _logger.debug("using microloader : {}", microloader);
            content = readFileContent(joinPath(sdk, "microloader", microloader));
            content = compressor.compress(content);
            remotes = [
                '<script type="text/javascript">' +
                    content + ';Ext.blink(' +
                    (environment == 'production' ? jsonEncode({
                        id:config.id
                    }) : appJson) + ')' +
                    '</script>'
            ];
    
    
            each(remoteAssets, function (asset) {
                var uri = asset.path;
    
    
                if (asset.type === 'js') {
                    remotes.push(
                        '<script type="text/javascript" src="' +
                            uri +
                            '"></script>');
                } else if (asset.type === 'css') {
                    remotes.push(
                        '<link rel="stylesheet" type="text/css" href="' +
                            uri +
                            '" />');
                }
            });
    
    
            indexHtml = ('' + indexHtml).replace(
                /<script id="microloader"([^<]+)<\/script>/,
                remotes.join(''));
    
    
            _logger.debug("generating new built index.html");
            writeFileContent(resolvePath(destination, indexHtmlPath), indexHtml);
            _logger.info("Embedded microloader into " + indexHtmlPath);
        };
    
    
        _logger.info("Resolving your application dependencies (" + appUrl + ")");
    
    
        var preprocessor = new Parser(),
            jsCompressor = new YuiJavascriptCompressor(),
            cssCompressor = new YuiCssCompressor(),
            phantomRunner = new PhantomJsRunner(),
            processedAssetCount = 0,
            assetsCount, dependencies, files, file,
            destinationFile, compressor;
    
    
        if(v2deps) {
            // if v2deps, use the sencha command 2 sytle dependency resolution mechanism
            // by running the phantomjs dependencies.js script
            var phantomOut = phantomRunner.run([
                    resolvePath(basedir, "dependencies.js"),
                    appUrl
                ]),
                exitCode = phantomOut.getExitCode(),
                stdout = phantomOut.getOutput(),
                buffer = new StringBuilder();
    
    
    
    
            if (exitCode > 0) {
                _logger.error("dependencies.js exited with non-zero code : " + exitCode);
                _logger.error(stdout);
                throw new ExBuild("failed gathering dependencies").raise();
            }
            dependencies = jsonDecode(stdout);
    
    
            _logger.info("Found " + dependencies.length + " dependencies. Concatenating all into '" + appJs + "'");
    
    
            files = map(dependencies, function (dependency) {
                return resolvePath(src, dependency.path);
            });
    
    
            files.push(appJs);
    
    
            each(files, function (file) {
                buffer.append(FileUtil.readUnicodeFile(resolvePath(file))).append('\n');
            });
    
    
            writeFileContent(appJs, buffer.toString());
    
    
            // clear the buffer to free memory
            buffer.setLength(0);
        } else {
            // else, use the sencha command 3 compiler to resolve application dependencies
            var ignores="src/locale,src/platform,auth2/Auth.js,scroller/Infinite.js",
                args = [
                    'compile',
                    '--ignore=' + ignores,
                    '--options=debug:false,logger:false,minVersion:3,product:touch',
                    'union',
                    '--recursive',
                    '--file=app.js',
                    'and',
                    'concatenate',
                    '-out=' + appJs
                ],
                compiler = new Sencha();
    
    
            _logger.info("Compiling app.js and dependencies");
            _logger.debug("running compiler with options : '{}'", args.join(' '));
            compiler.dispatch(args);
            _logger.info("Completed compilation.");
        }
    
    
    
    
        for (name in config.buildOptions) {
            if (config.buildOptions.hasOwnProperty(name)) {
                preprocessor.setParam(name, config.buildOptions[name]);
            }
            
        }
    
    
        assetsCount = assets.length;
    
    
        each(assets, function (asset) {
            file = asset.path;
            destinationFile = resolvePath(destination, file);
    
    
            var cleanFile = stripSpecialDirNames(file),
                cleanDestinationFile = resolvePath(destination, cleanFile);
    
    
            // adjust the asset path to use the cleaned filename
            asset.path = cleanFile;
    
    
            _logger.debug("Assets => Processed : {} Total : {}",
                processedAssetCount, assetsCount);
    
    
            if (asset.type == 'js') {
                if (!asset.remote && !asset.skipFrameworkFile) {
                    _logger.debug("running preprocessor for file {}", destinationFile);
                    writeFileContent(
                        cleanDestinationFile,
                        preprocessor.parse(readFileContent(destinationFile,true)));
                    _logger.info('Processed local file ' + file);
                } else {
                    _logger.info('Processed remote file ' + file);
                }
            }
    
    
            if (environment == 'testing') {
                return;
            }
    
    
            if (asset.remote || asset.skipFrameworkFile) {
                ++processedAssetCount;
            } else {
                _logger.debug("Minifying " + file);
    
    
                compressor = (asset.type == 'js')
                    ? jsCompressor
                    : cssCompressor;
                _logger.info(cleanDestinationFile);
                writeFileContent(
                    cleanDestinationFile,
                    compressor.compress(readFileContent(cleanDestinationFile,true)));
    
    
                _logger.info("Minified " + file);
    
    
                if (environment == 'production') {
                    var content = readFileContent(cleanDestinationFile),
                        version = '' + FileUtil.createChecksum(content);
                    asset.version = version;
    
    
                    _logger.debug("prepending checksum on {}", cleanDestinationFile);
                    writeFileContent(
                        cleanDestinationFile,
                        "/*" + version  + "*/" + content);
                    content = "";
    
    
                    _logger.debug("copying destination to archive");
    
    
                    PathUtil.ensurePathExists(resolvePath(archive, cleanFile, version));
                    copy(cleanDestinationFile, resolvePath(archive, cleanFile, version));
    
    
                    if (asset.update == 'delta') {
                        // generate all the deltas to the other archived versions
                        _logger.debug("generating file deltas");
                        var archivedVersions = new File(joinPath(archive, cleanFile))
                            .listFiles();
    
    
                        each(archivedVersions, function (archivedVersion) {
                            archivedVersion = archivedVersion.name;
    
    
                            if (archivedVersion == version) {
                                return;
                            }
    
    
                            var deltaFile = joinPath(
                                destination,
                                'deltas',
                                cleanFile,
                                archivedVersion + '.json');
    
    
                            writeFileContent(deltaFile, '');
    
    
                            _logger.debug("Generating delta from {} to {}",
                                archivedVersion,
                                version);
    
    
                            var runner = new VcDiffRunner(),
                                args = [
                                    'encode',
                                    '-json',
                                    '-dictionary',
                                    joinPath(archive, cleanFile, archivedVersion),
                                    '-target',
                                    cleanDestinationFile,
                                    '-delta',
                                    resolvePath(deltaFile),
                                    '--stats'
                                ],
                                runnerOut = runner.run(args),
                                exitCode = runnerOut.getExitCode(),
                                stdout = runnerOut.getOutput();
    
    
                            if (exitCode > 0) {
                                _logger.error("failed generating diff from {} to {}",
                                    archivedVersion,
                                    version);
                                _logger.error(stdout);
                                throw new ExBuild("failed generating diff from {0} to {1}",
                                    archivedVersion,
                                    version).raise();
                            }
                            _logger.info(
                                "Generated delta for: {} from hash: '{}' to hash: '{}'",
                                [cleanFile, archivedVersion, version]);
                        });
    
    
                    }
                }
    
    
                if (++processedAssetCount == assetsCount) {
                    _logger.debug("processed all assets, finalizing build...");
                    processIndex();
    
    
                    if (environment == 'production' && appCache) {
                        _logger.info("Generating appcache");
                        appCache.cache = map(appCache.cache, function (cache) {
                            var checksum = '';
    
    
                            if (!/^(\/|(.*):\/\/)/.test(cache)) {
                                _logger.info(
                                    "Generating checksum for appCache item: {}",
                                    cache);
    
    
                                checksum = FileUtil.createChecksum(
                                    readFileContent(joinPath(destination, cache)));
                            }
    
    
                            return {
                                uri:cache,
                                checksum:checksum
                            }
                        });
    
    
                        writeAppCache(appCache, joinPath(destination, 'cache.appcache'));
                    }
    
    
                    if (nativePackaging) {
                        _logger.debug("generating native package");
                        var packagerJson = readFileContent(
                                joinPath(src, 'packager.json'),true),
                            packagerConfig = jsonDecode(packagerJson);
    
    
                        if (packagerConfig.platform.match(/iOS/)) {
                            copy(
                                resolvePath(joinPath(src, 'resources', 'icons')),
                                resolvePath(destination),
                                ignoreFilter);
                            copy(
                                resolvePath(joinPath(src, 'resources', 'loading')),
                                resolvePath(destination),
                                ignoreFilter);
                        }
    
    
                        // add '' here to coerce to javascript string instead of java string
                        // for json encoding later...
                        packagerConfig.inputPath = destination + '';
                        packagerConfig.outputPath = resolvePath(config.buildPaths['native']) + '';
    
    
                        PathUtil.ensurePathExists(packagerConfig.outputPath);
    
    
                        writeFileContent(
                            joinPath(src, 'packager.temp.json'),
                            jsonEncode(packagerConfig));
    
    
                        _logger.info("Packaging your application as a native app...");
    
    
                        var stbuildRunner = new StBuildRunner(),
                            args = ['run', resolvePath(src, 'packager.temp.json')],
                            stbuildOut = stbuildRunner.run(args),
                            exitCode = stbuildOut.getExitCode(),
                            stdout = stbuildOut.getOutput();
    
    
                        if (exitCode > 0) {
                            _logger.error("failed running native packager");
                            _logger.error(stdout);
                            throw new ExBuild("failed running native packager")
                                .raise();
                        }
                    } else {
                        _logger.debug("skipping native packaging");
                    }
                }
            }
        });
    
    
        if (environment == 'testing') {
            processIndex();
        }
    }
    
    
    function writeAppCache(appCache, outfile) {
        _logger.debug("generating appcache manifest...");
        // build the appCache file
        var builder = new StringBuilder();
    
    
        builder.append("CACHE MANIFEST\n");
        each(appCache.cache, function (cache) {
            builder.append("# " + cache.checksum + "\n");
            builder.append(cache.uri + "\n");
        });
    
    
        builder.append("\n\nFALLBACK:\n");
    
    
        each(appCache.fallback, function (fallback) {
            builder.append(fallback + '\n');
        });
    
    
        builder.append("\n\nNETWORK:\n");
    
    
        each(appCache.network, function (network) {
            builder.append(network + '\n');
        });
    
    
        writeFileContent(
            outfile,
            builder.toString());
    
    
        builder.setLength(0);
    }
    
    
    
    
    (function (proj) {
        try {
            _logger.info("building application");
            runAppBuild(proj);
        } catch (err) {
            _logger.error("Exception running app build : " + err);
            throw err;
        }
    })(project);
    I write English by translator.

  10. #10
    Sencha Premium Member
    Join Date
    Feb 2012
    Location
    Berne, Switzerland
    Posts
    714
    Answers
    41
    Vote Rating
    42
    ingo.hefti has a spectacular aura about ingo.hefti has a spectacular aura about ingo.hefti has a spectacular aura about

      0  

    Default


    Thanks haduki - however problem remains...

    I put some additional logging into your modified JS. So I can see that is uses your modified readFileContent() function. But the native packed app still spits out crapped chars...