cordova-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From bhigg...@apache.org
Subject [12/38] git commit: Add blackberry10 support from JavaScript side.
Date Wed, 30 Jul 2014 19:06:29 GMT
Add blackberry10 support from JavaScript side.

* It is just a wrapper and needs native side support to work.


Project: http://git-wip-us.apache.org/repos/asf/cordova-plugin-globalization/repo
Commit: http://git-wip-us.apache.org/repos/asf/cordova-plugin-globalization/commit/7c72cb9c
Tree: http://git-wip-us.apache.org/repos/asf/cordova-plugin-globalization/tree/7c72cb9c
Diff: http://git-wip-us.apache.org/repos/asf/cordova-plugin-globalization/diff/7c72cb9c

Branch: refs/heads/lyon-g11n
Commit: 7c72cb9ca5589765f45f4a0a419fc35e09aceb00
Parents: 73a8121
Author: Lianghui Chen <liachen@blackberry.com>
Authored: Fri Jul 11 11:16:04 2014 -0400
Committer: Lianghui Chen <liachen@blackberry.com>
Committed: Mon Jul 28 15:10:45 2014 -0400

----------------------------------------------------------------------
 plugin.xml                |   7 +
 src/blackberry10/index.js | 634 +++++++++++++++++++++++++++++++++++++++++
 2 files changed, 641 insertions(+)
----------------------------------------------------------------------


http://git-wip-us.apache.org/repos/asf/cordova-plugin-globalization/blob/7c72cb9c/plugin.xml
----------------------------------------------------------------------
diff --git a/plugin.xml b/plugin.xml
index a0a3a21..d6d0e32 100644
--- a/plugin.xml
+++ b/plugin.xml
@@ -119,4 +119,11 @@
             <runs/>
         </js-module>
     </platform>
+
+    <!-- blackberry10 -->
+    <platform name="blackberry10">
+        <source-file src="src/blackberry10/index.js" target-dir="Globalization" />
+        <lib-file src="src/blackberry10/native/device/libGlobalization.so" arch="device"
/>
+        <lib-file src="src/blackberry10/native/simulator/libGlobalization.so" arch="simulator"
/>
+    </platform>
 </plugin>

http://git-wip-us.apache.org/repos/asf/cordova-plugin-globalization/blob/7c72cb9c/src/blackberry10/index.js
----------------------------------------------------------------------
diff --git a/src/blackberry10/index.js b/src/blackberry10/index.js
new file mode 100644
index 0000000..0cfcb05
--- /dev/null
+++ b/src/blackberry10/index.js
@@ -0,0 +1,634 @@
+/*
+ *
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ *
+*/
+
+var g11n;
+
+var globalization = {
+    /**
+    * Returns the string identifier for the client's current language.
+    * It returns the language identifier string to the successCB callback with a
+    * properties object as a parameter. If there is an error getting the language,
+    * then the errorCB callback is invoked.
+    *
+    * @param {Function} successCB
+    * @param {Function} errorCB
+    *
+    * @return Object.value {String}: The language identifier
+    *
+    * @error GlobalizationError.UNKNOWN_ERROR
+    *
+    * Example
+    *    globalization.getPreferredLanguage(function (language) {alert('language:' + language.value
+ '\n');},
+    *                                function () {});
+    */
+    getPreferredLanguage:function(successCB, failureCB, args, env) {
+        var result = new PluginResult(args, env),
+            response = g11n.getInstance().InvokeMethod("getPreferredLanguage", args),
+            data = JSON.parse(response);
+        console.log("getPreferredLanguage: " + JSON.stringify(response));
+
+        if (data.error != undefined) {
+            result.error({
+                code: data.error.code,
+                message: data.error.message
+            });
+        } else {
+            result.ok({
+                value: data.result
+            });
+        }
+    },
+
+    /**
+    * Returns the string identifier for the client's current locale setting.
+    * It returns the locale identifier string to the successCB callback with a
+    * properties object as a parameter. If there is an error getting the locale,
+    * then the errorCB callback is invoked.
+    *
+    * @param {Function} successCB
+    * @param {Function} errorCB
+    *
+    * @return Object.value {String}: The locale identifier
+    *
+    * @error GlobalizationError.UNKNOWN_ERROR
+    *
+    * Example
+    *    globalization.getLocaleName(function (locale) {alert('locale:' + locale.value +
'\n');},
+    *                                function () {});
+    */
+    getLocaleName:function(successCB, failureCB, args, env) {
+        var result = new PluginResult(args, env),
+            response = g11n.getInstance().InvokeMethod("getLocaleName", args),
+            data = JSON.parse(response);
+        console.log("getLocaleName: " + JSON.stringify(response));
+
+        if (data.error != undefined) {
+            result.error({
+                code: data.error.code,
+                message: data.error.message
+            });
+        } else {
+            result.ok({
+                value: data.result
+            });
+        }
+    },
+
+
+    /**
+    * Returns a date formatted as a string according to the client's user preferences and
+    * calendar using the time zone of the client. It returns the formatted date string to
the
+    * successCB callback with a properties object as a parameter. If there is an error
+    * formatting the date, then the errorCB callback is invoked.
+    *
+    * The defaults are: formatLenght="short" and selector="date and time"
+    *
+    * @param {Date} date
+    * @param {Function} successCB
+    * @param {Function} errorCB
+    * @param {Object} options {optional}
+    *            formatLength {String}: 'short', 'medium', 'long', or 'full'
+    *            selector {String}: 'date', 'time', or 'date and time'
+    *
+    * @return Object.value {String}: The localized date string
+    *
+    * @error GlobalizationError.FORMATTING_ERROR
+    *
+    * Example
+    *    globalization.dateToString(new Date(),
+    *                function (date) {alert('date:' + date.value + '\n');},
+    *                function (errorCode) {alert(errorCode);},
+    *                {formatLength:'short'});
+    */
+    dateToString:function(successCB, failureCB, args, env) {
+        var result = new PluginResult(args, env),
+            response = g11n.getInstance().InvokeMethod("dateToString", args),
+            data = JSON.parse(response);
+        console.log("dateToString: " + JSON.stringify(response));
+
+        if (data.error != undefined) {
+            result.error({
+                code: data.error.code,
+                message: data.error.message
+            });
+        } else {
+            result.ok({
+                value: data.result
+            });
+        }
+    },
+
+
+    /**
+    * Parses a date formatted as a string according to the client's user
+    * preferences and calendar using the time zone of the client and returns
+    * the corresponding date object. It returns the date to the successCB
+    * callback with a properties object as a parameter. If there is an error
+    * parsing the date string, then the errorCB callback is invoked.
+    *
+    * The defaults are: formatLength="short" and selector="date and time"
+    *
+    * @param {String} dateString
+    * @param {Function} successCB
+    * @param {Function} errorCB
+    * @param {Object} options {optional}
+    *            formatLength {String}: 'short', 'medium', 'long', or 'full'
+    *            selector {String}: 'date', 'time', or 'date and time'
+    *
+    * @return    Object.year {Number}: The four digit year
+    *            Object.month {Number}: The month from (0 - 11)
+    *            Object.day {Number}: The day from (1 - 31)
+    *            Object.hour {Number}: The hour from (0 - 23)
+    *            Object.minute {Number}: The minute from (0 - 59)
+    *            Object.second {Number}: The second from (0 - 59)
+    *            Object.millisecond {Number}: The milliseconds (from 0 - 999),
+    *                                        not available on all platforms
+    *
+    * @error GlobalizationError.PARSING_ERROR
+    *
+    * Example
+    *    globalization.stringToDate('4/11/2011',
+    *                function (date) { alert('Month:' + date.month + '\n' +
+    *                    'Day:' + date.day + '\n' +
+    *                    'Year:' + date.year + '\n');},
+    *                function (errorCode) {alert(errorCode);},
+    *                {selector:'date'});
+    */
+    stringToDate:function(successCB, failureCB, args, env) {
+        var result = new PluginResult(args, env),
+            response = g11n.getInstance().InvokeMethod("stringToDate", args),
+            data = JSON.parse(response);
+        console.log("stringToDate: " + JSON.stringify(response));
+
+        if (data.error != undefined) {
+            result.error({
+                code: data.error.code,
+                message: data.error.message
+            });
+        } else {
+            result.ok({
+                year: data.result.year,
+                month: data.result.month,
+                day: data.result.day,
+                hour: data.result.hour,
+                minute: data.result.minute,
+                second: data.result.second,
+                millisecond: data.result.millisecond
+            });
+        }
+    },
+
+
+    /**
+    * Returns a pattern string for formatting and parsing dates according to the client's
+    * user preferences. It returns the pattern to the successCB callback with a
+    * properties object as a parameter. If there is an error obtaining the pattern,
+    * then the errorCB callback is invoked.
+    *
+    * The defaults are: formatLength="short" and selector="date and time"
+    *
+    * @param {Function} successCB
+    * @param {Function} errorCB
+    * @param {Object} options {optional}
+    *            formatLength {String}: 'short', 'medium', 'long', or 'full'
+    *            selector {String}: 'date', 'time', or 'date and time'
+    *
+    * @return    Object.pattern {String}: The date and time pattern for formatting and parsing
dates.
+    *                                    The patterns follow Unicode Technical Standard #35
+    *                                    http://unicode.org/reports/tr35/tr35-4.html
+    *            Object.timezone {String}: The abbreviated name of the time zone on the client
+    *            Object.utc_offset {Number}: The current difference in seconds between the
client's
+    *                                        time zone and coordinated universal time.
+    *            Object.dst_offset {Number}: The current daylight saving time offset in seconds
+    *                                        between the client's non-daylight saving's time
zone
+    *                                        and the client's daylight saving's time zone.
+    *
+    * @error GlobalizationError.PATTERN_ERROR
+    *
+    * Example
+    *    globalization.getDatePattern(
+    *                function (date) {alert('pattern:' + date.pattern + '\n');},
+    *                function () {},
+    *                {formatLength:'short'});
+    */
+    getDatePattern:function(successCB, failureCB, args, env) {
+        var result = new PluginResult(args, env),
+            response = g11n.getInstance().InvokeMethod("getDatePattern", args),
+            data = JSON.parse(response);
+        console.log("getDatePattern: " + JSON.stringify(response));
+
+        if (data.error != undefined) {
+            result.error({
+                code: data.error.code,
+                message: data.error.message
+            });
+        } else {
+            result.ok({
+                pattern: data.result.pattern,
+                timezone: data.result.timezone,
+                utc_offset: data.result.utc_offset,
+                dst_offset: data.result.dst_offset
+            });
+        }
+    },
+
+
+    /**
+    * Returns an array of either the names of the months or days of the week
+    * according to the client's user preferences and calendar. It returns the array of names
to the
+    * successCB callback with a properties object as a parameter. If there is an error obtaining
the
+    * names, then the errorCB callback is invoked.
+    *
+    * The defaults are: type="wide" and item="months"
+    *
+    * @param {Function} successCB
+    * @param {Function} errorCB
+    * @param {Object} options {optional}
+    *            type {String}: 'narrow' or 'wide'
+    *            item {String}: 'months', or 'days'
+    *
+    * @return Object.value {Array{String}}: The array of names starting from either
+    *                                        the first month in the year or the
+    *                                        first day of the week.
+    * @error GlobalizationError.UNKNOWN_ERROR
+    *
+    * Example
+    *    globalization.getDateNames(function (names) {
+    *        for(var i = 0; i < names.value.length; i++) {
+    *            alert('Month:' + names.value[i] + '\n');}},
+    *        function () {});
+    */
+    getDateNames:function(successCB, failureCB, args, env) {
+        var result = new PluginResult(args, env),
+            response = g11n.getInstance().InvokeMethod("getDateNames", args),
+            data = JSON.parse(response);
+        console.log("getDateNames: " + JSON.stringify(response));
+
+        if (data.error != undefined) {
+            result.error({
+                code: data.error.code,
+                message: data.error.message
+            });
+        } else {
+            result.ok({
+                value: data.result
+            });
+        }
+    },
+
+    /**
+    * Returns whether daylight savings time is in effect for a given date using the client's
+    * time zone and calendar. It returns whether or not daylight savings time is in effect
+    * to the successCB callback with a properties object as a parameter. If there is an error
+    * reading the date, then the errorCB callback is invoked.
+    *
+    * @param {Date} date
+    * @param {Function} successCB
+    * @param {Function} errorCB
+    *
+    * @return Object.dst {Boolean}: The value "true" indicates that daylight savings time
is
+    *                                in effect for the given date and "false" indicate that
it is not.
+    *
+    * @error GlobalizationError.UNKNOWN_ERROR
+    *
+    * Example
+    *    globalization.isDayLightSavingsTime(new Date(),
+    *                function (date) {alert('dst:' + date.dst + '\n');}
+    *                function () {});
+    */
+    isDayLightSavingsTime:function(successCB, failureCB, args, env) {
+        var result = new PluginResult(args, env),
+            response = g11n.getInstance().InvokeMethod("isDayLightSavingsTime", args),
+            data = JSON.parse(response);
+        console.log("isDayLightSavingsTime: " + JSON.stringify(response));
+
+        if (data.error != undefined) {
+            result.error({
+                code: data.error.code,
+                message: data.error.message
+            });
+        } else {
+            result.ok({
+                dst: data.result
+            });
+        }
+    },
+
+    /**
+    * Returns the first day of the week according to the client's user preferences and calendar.
+    * The days of the week are numbered starting from 1 where 1 is considered to be Sunday.
+    * It returns the day to the successCB callback with a properties object as a parameter.
+    * If there is an error obtaining the pattern, then the errorCB callback is invoked.
+    *
+    * @param {Function} successCB
+    * @param {Function} errorCB
+    *
+    * @return Object.value {Number}: The number of the first day of the week.
+    *
+    * @error GlobalizationError.UNKNOWN_ERROR
+    *
+    * Example
+    *    globalization.getFirstDayOfWeek(function (day)
+    *                { alert('Day:' + day.value + '\n');},
+    *                function () {});
+    */
+    getFirstDayOfWeek:function(successCB, failureCB, args, env) {
+        var result = new PluginResult(args, env),
+            response = g11n.getInstance().InvokeMethod("getFirstDayOfWeek", args),
+            data = JSON.parse(response);
+        console.log("getFirstDayOfWeek: " + JSON.stringify(response));
+
+        if (data.error != undefined) {
+            result.error({
+                code: data.error.code,
+                message: data.error.message
+            });
+        } else {
+            result.ok({
+                value: data.result
+            });
+        }
+    },
+
+
+    /**
+    * Returns a number formatted as a string according to the client's user preferences.
+    * It returns the formatted number string to the successCB callback with a properties
object as a
+    * parameter. If there is an error formatting the number, then the errorCB callback is
invoked.
+    *
+    * The defaults are: type="decimal"
+    *
+    * @param {Number} number
+    * @param {Function} successCB
+    * @param {Function} errorCB
+    * @param {Object} options {optional}
+    *            type {String}: 'decimal', "percent", or 'currency'
+    *
+    * @return Object.value {String}: The formatted number string.
+    *
+    * @error GlobalizationError.FORMATTING_ERROR
+    *
+    * Example
+    *    globalization.numberToString(3.25,
+    *                function (number) {alert('number:' + number.value + '\n');},
+    *                function () {},
+    *                {type:'decimal'});
+    */
+    numberToString:function(successCB, failureCB, args, env) {
+        var result = new PluginResult(args, env),
+            response = g11n.getInstance().InvokeMethod("numberToString", args),
+            data = JSON.parse(response);
+        console.log("numberToString: " + JSON.stringify(response));
+
+        if (data.error != undefined) {
+            result.error({
+                code: data.error.code,
+                message: data.error.message
+            });
+        } else {
+            result.ok({
+                value: data.result
+            });
+        }
+    },
+
+    /**
+    * Parses a number formatted as a string according to the client's user preferences and
+    * returns the corresponding number. It returns the number to the successCB callback with
a
+    * properties object as a parameter. If there is an error parsing the number string, then
+    * the errorCB callback is invoked.
+    *
+    * The defaults are: type="decimal"
+    *
+    * @param {String} numberString
+    * @param {Function} successCB
+    * @param {Function} errorCB
+    * @param {Object} options {optional}
+    *            type {String}: 'decimal', "percent", or 'currency'
+    *
+    * @return Object.value {Number}: The parsed number.
+    *
+    * @error GlobalizationError.PARSING_ERROR
+    *
+    * Example
+    *    globalization.stringToNumber('1234.56',
+    *                function (number) {alert('Number:' + number.value + '\n');},
+    *                function () { alert('Error parsing number');});
+    */
+    stringToNumber:function(successCB, failureCB, args, env) {
+        var result = new PluginResult(args, env),
+            response = g11n.getInstance().InvokeMethod("stringToNumber", args),
+            data = JSON.parse(response);
+        console.log("stringToNumber: " + JSON.stringify(response));
+
+        if (data.error != undefined) {
+            result.error({
+                code: data.error.code,
+                message: data.error.message
+            });
+        } else {
+            result.ok({
+                value: data.result
+            });
+        }
+    },
+
+    /**
+    * Returns a pattern string for formatting and parsing numbers according to the client's
user
+    * preferences. It returns the pattern to the successCB callback with a properties object
as a
+    * parameter. If there is an error obtaining the pattern, then the errorCB callback is
invoked.
+    *
+    * The defaults are: type="decimal"
+    *
+    * @param {Function} successCB
+    * @param {Function} errorCB
+    * @param {Object} options {optional}
+    *            type {String}: 'decimal', "percent", or 'currency'
+    *
+    * @return    Object.pattern {String}: The number pattern for formatting and parsing numbers.
+    *                                    The patterns follow Unicode Technical Standard #35.
+    *                                    http://unicode.org/reports/tr35/tr35-4.html
+    *            Object.symbol {String}: The symbol to be used when formatting and parsing
+    *                                    e.g., percent or currency symbol.
+    *            Object.fraction {Number}: The number of fractional digits to use when parsing
and
+    *                                    formatting numbers.
+    *            Object.rounding {Number}: The rounding increment to use when parsing and
formatting.
+    *            Object.positive {String}: The symbol to use for positive numbers when parsing
and formatting.
+    *            Object.negative: {String}: The symbol to use for negative numbers when parsing
and formatting.
+    *            Object.decimal: {String}: The decimal symbol to use for parsing and formatting.
+    *            Object.grouping: {String}: The grouping symbol to use for parsing and formatting.
+    *
+    * @error GlobalizationError.PATTERN_ERROR
+    *
+    * Example
+    *    globalization.getNumberPattern(
+    *                function (pattern) {alert('Pattern:' + pattern.pattern + '\n');},
+    *                function () {});
+    */
+    getNumberPattern:function(successCB, failureCB, args, env) {
+        var result = new PluginResult(args, env),
+            response = g11n.getInstance().InvokeMethod("getNumberPattern", args),
+            data = JSON.parse(response);
+        console.log("getNumberPattern: " + JSON.stringify(response));
+
+        if (data.error != undefined) {
+            result.error({
+                code: data.error.code,
+                message: data.error.message
+            });
+        } else {
+            result.ok({
+                pattern: data.result.pattern,
+                symbol: data.result.symbol,
+                fraction: data.result.fraction,
+                rounding: data.result.rounding,
+                positive: data.result.positive,
+                negative: data.result.negative,
+                decimal: data.result.decimal,
+                grouping: data.result.grouping
+            });
+        }
+    },
+
+    /**
+    * Returns a pattern string for formatting and parsing currency values according to the
client's
+    * user preferences and ISO 4217 currency code. It returns the pattern to the successCB
callback with a
+    * properties object as a parameter. If there is an error obtaining the pattern, then
the errorCB
+    * callback is invoked.
+    *
+    * @param {String} currencyCode
+    * @param {Function} successCB
+    * @param {Function} errorCB
+    *
+    * @return    Object.pattern {String}: The currency pattern for formatting and parsing
currency values.
+    *                                    The patterns follow Unicode Technical Standard #35
+    *                                    http://unicode.org/reports/tr35/tr35-4.html
+    *            Object.code {String}: The ISO 4217 currency code for the pattern.
+    *            Object.fraction {Number}: The number of fractional digits to use when parsing
and
+    *                                    formatting currency.
+    *            Object.rounding {Number}: The rounding increment to use when parsing and
formatting.
+    *            Object.decimal: {String}: The decimal symbol to use for parsing and formatting.
+    *            Object.grouping: {String}: The grouping symbol to use for parsing and formatting.
+    *
+    * @error GlobalizationError.FORMATTING_ERROR
+    *
+    * Example
+    *    globalization.getCurrencyPattern('EUR',
+    *                function (currency) {alert('Pattern:' + currency.pattern + '\n');}
+    *                function () {});
+    */
+    getCurrencyPattern:function(successCB, failureCB, args, env) {
+        var result = new PluginResult(args, env),
+            response = g11n.getInstance().InvokeMethod("getCurrencyPattern", args),
+            data = JSON.parse(response);
+        console.log("getCurrencyPattern: " + JSON.stringify(response));
+
+        if (data.error != undefined) {
+            result.error({
+                code: data.error.code,
+                message: data.error.message
+            });
+        } else {
+            result.ok({
+                pattern: data.result.pattern,
+                code: data.result.code,
+                fraction: data.result.fraction,
+                rounding: data.result.rounding,
+                decimal: data.result.decimal,
+                grouping: data.result.grouping
+            });
+        }
+    }
+};
+
+module.exports = globalization;
+
+function lineArgsFromArray(args) {
+    var cmd = "";
+
+    if ("callbackId" in args)
+        cmd += decodeURIComponent(args["callbackId"]);
+    if ("0" in args) {
+        if (cmd.length > 0)
+            cmd += " ";
+        cmd += decodeURIComponent(args["0"]);
+    }
+
+    return cmd;
+}
+
+function cmdLineForMethod(method, args) {
+    var cmd = lineArgsFromArray(args);
+    if (cmd.length > 0)
+        return method + " " + cmd;
+    else
+        return method;
+}
+
+///////////////////////////////////////////////////////////////////
+// JavaScript wrapper for JNEXT plugin
+///////////////////////////////////////////////////////////////////
+
+JNEXT.Globalization = function () {
+    var self = this,
+        hasInstance = false;
+
+    self.InvokeMethod = function (method, args) {
+        //This is how Javascript calls into native
+        return JNEXT.invoke(self.m_id, cmdLineForMethod(method, args));
+    };
+
+    self.init = function () {
+        //Checks that the jnext library is present and loads it
+        if (!JNEXT.require("libGlobalization")) {
+            return false;
+        }
+
+        //Creates the native object that this interface will call
+        self.m_id = JNEXT.createObject("libGlobalization.Globalization");
+
+        if (self.m_id === "") {
+            return false;
+        }
+
+        //Registers for the JNEXT event loop
+        JNEXT.registerEvents(self);
+    };
+
+    self.m_id = "";
+
+    //Used by JNEXT library to get the ID
+    self.getId = function () {
+        return self.m_id;
+    };
+
+    //Not truly required but useful for instance management
+    self.getInstance = function () {
+        if (!hasInstance) {
+            self.init();
+            hasInstance = true;
+        }
+        return self;
+    };
+};
+
+g11n = new JNEXT.Globalization();
+


Mime
View raw message