It is used by `application.d.ts` and needs to be documented. The reason
that it wasn't included in the documentation by now is that `tns-core-modules.d.ts`
(which imports `module.d.ts`) defines types which are part of the internal
modules and runtimes APIs. As such they are excluded from the generation
of API documentation.
* fix: undefined root view when reapplying styles
Error:
```
JS ERROR TypeError: undefined is not an object (evaluating
'application_1.getRootView()._onCssStateChange')
```
Steps:
- `tns run <platform> --hmr`
- make a change in application styles
- restart the application
Expose `HmrContext` interface.
Apply changes in `app.css` instantly.
Avoid navigation on livesync when changes in `app.css` have been made.
Apply changes in `app.css` on back navigation.
* Add a "window" value so that NS doesn't crash on selectors looking for the delegate.window...
* chore: tslint
* chore: comments to referenced issues added
* feat(tns-platform-declarations): Generate iOS typings from iOS 12.1 SDK
* Instructions for generating iOS typescript definitions
* Refactor `typings-gen.sh` to use {N} CLI and generate fuller
metadata for the system libraries
* Automatically generate `ios.d.ts` wrapper
* Add interop pointers and references as alternatives
to `string` for `char*` args
(implemented in https://github.com/NativeScript/ios-runtime/pull/1022)
BREAKING CHANGE: Several enum values have changed because
they have been wrongly generated.
To migrate your app or plugin code use the new names of the
following:
* enum NSUnderlineStyle:
- `StyleNone` -> `None`
- `StyleSingle` -> `Single`
- `StyleThick` -> `Thick`
- `StyleDouble` -> `Double`
* enum AVAudioSessionErrorCode:
- `CodeNone` -> `None`
- `CodeMediaServicesFailed` -> `MediaServicesFailed`
- `CodeIsBusy` -> `IsBusy`
- `CodeIncompatibleCategory` -> `IncompatibleCategory`
- `CodeCannotInterruptOthers` -> `CannotInterruptOthers`
- `CodeMissingEntitlement` -> `MissingEntitlement`
- `CodeSiriIsRecording` -> `SiriIsRecording`
- `CodeCannotStartPlaying` -> `CannotStartPlaying`
- `CodeCannotStartRecording` -> `CannotStartRecording`
- `CodeBadParam` -> `BadParam`
- `CodeResourceNotAvailable` -> `ResourceNotAvailable`
- `CodeUnspecified` -> `Unspecified`
* fix(ui/text-base): Update NSUnderlineStyle.StyleSingle constant
After the typings regeneration its and several others' names have
changed to the expected `NSUnderlineStyle.Single`.
* fix(tns-platform-declarations): Restore deprecated enum values
In order to not introduce a breaking change in a patch version, we
are keeping `Style...` and `Code...` values that have been wrongly
generated till now. In the next major/minor release of the package
when the typings are regenerated we can safely remove them.
Revert to using the deprecated one's in `text-base.ios.ts` so that
the introduction of this breaking change doesn't slip in undetected.
* fix(application.ios): Directly call presetnNativeScriptApp
We've been using `performSelectorWithObject` but it's
declaration has been manually added. Moreover it's more
convenient to directly call the method.
Switch Activity / Fragment / FragmentManager implementation from native framework to support library APIs
BREAKING CHANGE:
NativeScript core framework now extends support library APIs versus native framework classes as per Google's latest guidelines:
- NativeScript activities now extend `android.support.v7.app.AppCompatActivity` (vs android.app.Activity)
- NativeScript fragments now extend `android.support.v4.app.Fragment` (vs android.app.Fragment)
- NativeScript now works internally with `android.support.v4.app.FragmentManager` (vs android.app.FragmentManager)
The implications of these changes should be mostly transparent to the developer except for the fact that the support library Fragment / FragmentManager work with Animation APIs versus Animator APIs.
For Android API Levels lower than 28 the new Fragment API uses a different fragment enter animation by default. You can customise the transition per navigation entry or globally via the [navigation transitions API](https://docs.nativescript.org/core-concepts/navigation#navigation-transitions)
Before:
Default fragment enter animation was fade animation
After:
Default fragment enter animation for API levels lower than 28 is now a fast "push fade" animation; default fragment enter animation for API levels equal to or greater than 28 remains fade animation
Before:
AndroidFragmentCallbacks interface exposed the following `onCreateAnimator(...)` method
``` ts
export interface AndroidFragmentCallbacks {
onCreateAnimator(fragment: any, transit: number, enter: boolean, nextAnim: number, superFunc: Function): any;
// ...
}
```
After:
AndroidFragmentCallbacks interface now exposes the following `onCreateAnimation(...)` method instead (and `onCreateAnimator(...)` is now removed)
``` ts
export interface AndroidFragmentCallbacks {
onCreateAnimation(fragment: any, transit: number, enter: boolean, nextAnim: number, superFunc: Function): any;
// ...
}
```
Before:
Transition class exposed the following abstract `createAndroidAnimator(...)` method
``` ts
export class Transition {
public createAndroidAnimator(transitionType: string): any;
// ...
}
```
After:
Transition class now exposes the following abstract `createAndroidAnimation(...)` method instead (and `createAndroidAnimation(...) is now removed)
``` ts
export class Transition {
public createAndroidAnimation(transitionType: string): any;
// ...
}
```
To migrate the code of your custom transitions follow the example below:
Before:
``` ts
import * as transition from "tns-core-modules/ui/transition";
export class CustomTransition extends transition.Transition {
constructor(duration: number, curve: any) {
super(duration, curve);
}
public createAndroidAnimator(transitionType: string): android.animation.Animator {
var scaleValues = Array.create("float", 2);
switch (transitionType) {
case transition.AndroidTransitionType.enter:
case transition.AndroidTransitionType.popEnter:
scaleValues[0] = 0;
scaleValues[1] = 1;
break;
case transition.AndroidTransitionType.exit:
case transition.AndroidTransitionType.popExit:
scaleValues[0] = 1;
scaleValues[1] = 0;
break;
}
var objectAnimators = Array.create(android.animation.Animator, 2);
objectAnimators[0] = android.animation.ObjectAnimator.ofFloat(null, "scaleX", scaleValues);
objectAnimators[1] = android.animation.ObjectAnimator.ofFloat(null, "scaleY", scaleValues);
var animatorSet = new android.animation.AnimatorSet();
animatorSet.playTogether(objectAnimators);
var duration = this.getDuration();
if (duration !== undefined) {
animatorSet.setDuration(duration);
}
animatorSet.setInterpolator(this.getCurve());
return animatorSet;
}
}
```
After:
``` ts
import * as transition from "tns-core-modules/ui/transition";
export class CustomTransition extends transition.Transition {
constructor(duration: number, curve: any) {
super(duration, curve);
}
public createAndroidAnimation(transitionType: string): android.view.animation.Animation {
const scaleValues = [];
switch (transitionType) {
case transition.AndroidTransitionType.enter:
case transition.AndroidTransitionType.popEnter:
scaleValues[0] = 0;
scaleValues[1] = 1;
break;
case transition.AndroidTransitionType.exit:
case transition.AndroidTransitionType.popExit:
scaleValues[0] = 1;
scaleValues[1] = 0;
break;
}
const animationSet = new android.view.animation.AnimationSet(false);
const duration = this.getDuration();
if (duration !== undefined) {
animationSet.setDuration(duration);
}
animationSet.setInterpolator(this.getCurve());
animationSet.addAnimation(
new android.view.animation.ScaleAnimation(
scaleValues[0],
scaleValues[1],
scaleValues[0],
scaleValues[1]
));
return animationSet;
}
}
```
* feat: Pass NS app native controller to the native app instead of presenting it over the rootViewController
When NativeScript embedded app is created from the native one we check for whether the topmost UIViewController has NativeScriptEmbedder protocol (implemented in the iOS Runtime) method 'presentNativeScriptApp:'. If yes, we call it with the NS app viewcontroller as a parameter so the embedder has control over the NS app (where and how to present it etc.) For backwards compatibility we present the NS app on top of the topmost UIViewController as a fallback.
* style: Fix lint errors
* feat: Check for protocol instead of selector in embedding
I
* Check for rootController instead of topViewController to prevent crash if !rootController
* feat: Introduce NativeScriptEmbedder singleton
NativeScriptEmbedder is responsive for communication between the NS and the native iOS app. His delegate will implement methods which we can call from javascript such as "presentNativeScriptApp:".
* feat: add option to set a different root view at run time
* feat: expose application getRootView method
* refactor: Introduce ViewEntry interface
* fix: Respect root view rturned from launch event in Android
* refactor: getRootView() code + caching root view per activity.
* refactor: add app-root.xml in apps
* refactor: http test made async
* feat: add a 'profiling: lifecycle' to track startup times
* feat: log when displayed event fires
* feat(ios): fire onDisplayed event when first frame is ready to be
displayed
fix livesync implementation to be compatible with 3.4 and to replace mainEntry for 4.0 when root is not Frame
some refactoring of page.ios in order to allow showing multiple modal dialogs
Fixed broken unit-tests
ios layout now run only for the innermost viewcontoller
ios layout for viewcontrollers now implemented with constraints
Added ios11 safeAreas layout support
onMeasure back for frame and tab-view so that they won't throw exception if measure is called on them
Page parents layout updated after page is layout so that inner layout flags are correct
