NativeScript – Native APIs Using JavaScript
”; Previous Next This section explains about the overview of accessing Native APIs using JavaScript.
Marshalling
The NativeScript Runtime provides implicit type conversion for both android and iOS platforms. This concept is known as marshalling. For example, NativeScript- iOS paltform can implicitly convert JavaScript and Objective-C data types similarly, Java/Kotlin can easily be mapped to JavaScript project types and values. Let us understand how to perform marshalling in each type one by one briefly.
Numeric Values
We can easily convert iOS and android numeric data types into JavaScript numbers. Simple numeric conversion for iOS into JavaScript is defined below −
console.log(`max(7,9) = ${max(7,9)}`);
Here,
The native max() function is converted into JavaScript number.
Android Environment
Java supports different numeric types such as byte, short, int, float, double and long. JavaScript has only number type.
Consider a simple Java class shown below −
class Demo extends java.lang.Object {
public int maxMethod(int a,int b) {
if(a>b) {
return a;
} else {
return b;
}
}
}
Here,
The above code contains two integer arguments. We can call the above code object using JavaScript as shown below −
//Create an instance for Demo class
var obj = new Demo();
//implicit integer conversion for calling the above method
obj.maxMethod(7,9);
Strings
Android strings are defined in java.lang.string and iOS strings are defined in NSSring. Let us see how to perform marshalling in both platforms.
Android
Strings are immutable but String buffers support mutable strings.
Below code is an example for simple mapping −
//Create android label widget
var label = new android.widget.Label();
//Create JavaScript string
var str = “Label1″;
//Convert JavaScript string into java label.setText(str);
// text is converted to java.lang.String
Boolean class is defined in java.lang.Boolean. This class wraps a value of boolean in an object. We can easily convert boolean to String and vice-versa. Simple example is defined as given below −
//create java string
let data = new java.lang.String(”NativeScript”);
//map java String to JavaScript string,
let result = data.startsWith(”N”);
//return result
console.log(result);// true
iOS environment
NSString class is immutable but its subclass NSMutableString is immutable. This class contains a collection of methods for working with strings. It is declared as below −
class NSString : NSObject
Consider a simple objective-c declaration as shown below −
NSString *str = @”nativescript”;
//convert the string to uppercase
NSString *str1;
str1 = [str uppercaseString];
NSLog(@”Uppercase String : %@n”, str1 );
NSStrings can easily be mapped to JavaScript strings.
Array
This section explains about how to perform marshalling in arrays. Let’s take an example of iOS environment first.
Array Declaration
class NSArray : NSObject
Here,
NSArray is used to manage ordered collection of objects called arrays. It is used to create static array. Its sub class NSMutableArray is used to create dynamic arrays.
Consider NSArray objects can be created using array literals as shown below −
let array: NSArray = [“React”,”Vue”,”TypeScript”]
Now, we can map this array into JavaScript as shown below −
//create native array
let nsArr = NSArray.arrayWithArray(“React”,”Vue”,”TypeScript”]);
//create simple javascript array
let jsArr = [“Hello,World”,”NativeScript”];
//Now compare the two arrays,
let compare = nsArr.isEqual(jsArr);
console.log(comapre);
This will return the output as false.
Android array declaration
Java arrays are defined in java.util.Arrays. This class contains various methods for manipulating arrays. An example is shown below −
//javascript array
let data = [12,45,23,56,34,78,50];
//create java array
let result = ns.example.Math.maxElement(data);
console.log(result);
Classes and Objects
Classes and Objects are basic concepts of Object Oriented Programming. Class is a user defined prototype. Object is an instance of class. Class represents the set of properties or methods that are common to all objects of one type. Let us understand native classes and objects for both mobile development environments.
Android Environment
Java and Kotlin classes have unique identifiers denoted by the full package name.
For example,
android.view.View − It is a basic user interface class for screen layout and interaction with the user. We can access this class in JavaScript as shown below −
const View = android.view.View;
First, we import the class using the below statement −
import android.view.View;
Next create a class as given below −
public class MyClass {
public static void staticMethod(context) {
//create view instance
android.view.View myview = new android.view.View(context);
}
}
In the above same class, we can access JavaScript function using the below code −
const myview = new android.view.View(context);
Similarly, we can access interfaces, constants and enumerations within java.lang packages.
iOS Environment
Objective-C classes are defined in two sections @interface and @implementation. Class definition starts with the keyword @interface followed by the interface(class) name. In Objective-C, all classes are derived from the base class called NSObject.
It is the superclass of all Objective-C classes. Simple Circle class is defined as shown below −
@interface Circle:NSObject {
//Instance variable
int radius;
}
@end
Consider a class with one method as shown below −
@interface MyClass : NSObject
+ (void)baseStaticMethod;
@end
This class can be converted to javascript using the below code −
function MyClass() { /* native call */ };
Object.setPrototypeOf(MyClass, NSObject);
BaseClass.baseStaticMethod = function () { /* native call */ };
JavaScript instanceof operator is used to verify, if an object inherits from a given class. This can be defined as −
var obj = MyClass.alloc().init(); //