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...

Turkiyenin en sevilen filmlerinin yer aldigi xnxx internet sitemiz olan ve porn sex tarzi bir site olan mobil porno izle sitemiz gercekten dillere destan bir durumda herkesin sevdigi bir site olarak tarihe gececege benziyor. Sitenin en belirgin ozelliklerinden birisi de Turkiyede gercekten kaliteli ve muntazam, duzenli porno izle siteleri olmamasidir. Bu yuzden iste. Ayrica en net goruntu kalitesine sahip adresinde yayinlanmaktadir. Mesela diğer sitelerimizden bahsedecek olursak, en iyi hd porno video arşivine sahip bir siteyiz. "The Best anal porn videos and slut anus, big asses movies set..." hd porno faketaxi