Rename the files

tns-core-modules/location/location.ios.ts

@@ -0,0 +1,181 @@
+import locationModule = require("location");
+import common = require("./location-common");
+
+global.moduleMerge(common, exports);
+
+class LocationListenerImpl extends NSObject implements CLLocationManagerDelegate {
+    public static ObjCProtocols = [CLLocationManagerDelegate];
+
+    static new(): LocationListenerImpl {
+        return <LocationListenerImpl>super.new();
+    }
+
+    private _onLocation: (location: locationModule.Location) => any;
+    private _onError: (error: Error) => any
+    private _options: locationModule.Options;
+    private _maximumAge: number;
+
+    public initWithLocationErrorOptions(location: (location: locationModule.Location) => any, error?: (error: Error) => any, options?: locationModule.Options): LocationListenerImpl {
+        this._onLocation = location;
+        
+        if (error) {
+            this._onError = error;
+        }
+
+        if (options) {
+            this._options = options;
+        }
+
+        this._maximumAge = (this._options && ("number" === typeof this._options.maximumAge)) ? this._options.maximumAge : undefined;
+
+        return this;
+    }
+
+    public locationManagerDidUpdateLocations(manager, locations): void {
+        for (var i = 0; i < locations.count; i++) {
+            var location = LocationManager._locationFromCLLocation(locations.objectAtIndex(i));
+            if (this._maximumAge) {
+                if (location.timestamp.valueOf() + this._maximumAge > new Date().valueOf()) {
+                    this._onLocation(location);
+                }
+            }
+            else {
+                this._onLocation(location);
+            }
+        }
+    }
+
+    public locationManagerDidFailWithError(manager, error): void {
+        if (this._onError) {
+            this._onError(new Error(error.localizedDescription));
+        }
+    }
+}
+
+@Deprecated
+export class LocationManager implements locationModule.LocationManager {
+	get android(): locationModule.AndroidLocationManager {
+		return undefined;
+	}
+
+	get ios(): locationModule.iOSLocationManager {
+		return this.iosLocationManager;
+	}
+
+	public isStarted: boolean;
+    // in meters
+    // we might need some predefined values here like 'any' and 'high'
+    public desiredAccuracy: number;
+
+	// The minimum distance (measured in meters) a device must move horizontally before an update event is generated.
+    public updateDistance: number;
+
+    private iosLocationManager: locationModule.iOSLocationManager;
+    private listener: any;
+
+    public static _locationFromCLLocation(clLocation: CLLocation): locationModule.Location {
+        var location = new locationModule.Location();
+        location.latitude = clLocation.coordinate.latitude;
+        location.longitude = clLocation.coordinate.longitude;
+        location.altitude = clLocation.altitude;
+        location.horizontalAccuracy = clLocation.horizontalAccuracy;
+        location.verticalAccuracy = clLocation.verticalAccuracy;
+        location.speed = clLocation.speed;
+        location.direction = clLocation.course;
+		var timeIntervalSince1970 = NSDate.dateWithTimeIntervalSinceDate(0, clLocation.timestamp).timeIntervalSince1970;
+        location.timestamp = new Date(timeIntervalSince1970 * 1000);
+        location.ios = clLocation;
+        return location;
+    }
+
+    private static iosLocationFromLocation(location: locationModule.Location): CLLocation {
+        var hAccuracy = location.horizontalAccuracy ? location.horizontalAccuracy : -1;
+        var vAccuracy = location.verticalAccuracy ? location.verticalAccuracy : -1;
+        var speed = location.speed ? location.speed : -1;
+        var course = location.direction ? location.direction : -1;
+        var altitude = location.altitude ? location.altitude : -1;
+        var timestamp = location.timestamp ? NSDate.dateWithTimeIntervalSince1970(location.timestamp.getTime() / 1000) : null;
+        var iosLocation = CLLocation.alloc().initWithCoordinateAltitudeHorizontalAccuracyVerticalAccuracyCourseSpeedTimestamp(CLLocationCoordinate2DMake(location.latitude, location.longitude), altitude, hAccuracy, vAccuracy, course, speed, timestamp);
+        return iosLocation;
+    }
+
+    public static isEnabled(): boolean {
+        if (CLLocationManager.locationServicesEnabled()) {
+            // CLAuthorizationStatus.kCLAuthorizationStatusAuthorizedWhenInUse and CLAuthorizationStatus.kCLAuthorizationStatusAuthorizedAlways are options that are available in iOS 8.0+
+            // while CLAuthorizationStatus.kCLAuthorizationStatusAuthorized is here to support iOS 8.0-.
+            return (CLLocationManager.authorizationStatus() === CLAuthorizationStatus.kCLAuthorizationStatusAuthorizedWhenInUse 
+                || CLLocationManager.authorizationStatus() === CLAuthorizationStatus.kCLAuthorizationStatusAuthorizedAlways
+                || CLLocationManager.authorizationStatus() === CLAuthorizationStatus.kCLAuthorizationStatusAuthorized);
+        }
+        return false;
+    }
+
+    public static distance(loc1: locationModule.Location, loc2: locationModule.Location): number {
+        if (!loc1.ios) {
+            loc1.ios = LocationManager.iosLocationFromLocation(loc1);
+        }
+        if (!loc2.ios) {
+            loc2.ios = LocationManager.iosLocationFromLocation(loc2);
+        }
+        return loc1.ios.distanceFromLocation(loc2.ios);
+    }
+
+    constructor() {
+		//super();
+        var enums = require("ui/enums");
+
+        this.desiredAccuracy = enums.Accuracy.any;
+        this.updateDistance = kCLDistanceFilterNone;
+		var iosLocManager = new CLLocationManager();
+        this.iosLocationManager = new iOSLocationManager(iosLocManager);
+    }
+
+    public startLocationMonitoring(onLocation: (location: locationModule.Location) => any, onError?: (error: Error) => any, options?: locationModule.Options) {
+        if (!this.listener) {
+            if (options) {
+                if (options.desiredAccuracy) {
+                    this.desiredAccuracy = options.desiredAccuracy;
+                }
+                if (options.updateDistance) {
+                    this.updateDistance = options.updateDistance;
+                }
+            }
+
+            this.listener = LocationListenerImpl.new().initWithLocationErrorOptions(onLocation, onError, options);
+            this.iosLocationManager.manager.delegate = this.listener;
+            this.iosLocationManager.manager.desiredAccuracy = this.desiredAccuracy;
+            this.iosLocationManager.manager.distanceFilter = this.updateDistance;
+            this.iosLocationManager.manager.startUpdatingLocation();
+			this.isStarted = true;
+        }
+    }
+
+    public stopLocationMonitoring() {
+        this.iosLocationManager.manager.stopUpdatingLocation();
+        this.iosLocationManager.manager.delegate = null;
+        this.listener = null;
+		this.isStarted = false;
+    }
+
+    get lastKnownLocation(): locationModule.Location {
+        var clLocation = this.iosLocationManager.manager.location;
+        if (clLocation) {
+            return LocationManager._locationFromCLLocation(clLocation);
+        }
+        return null;
+    }
+}
+
+/* tslint:disable */
+@Deprecated
+export class iOSLocationManager implements locationModule.iOSLocationManager {
+	private _manager: CLLocationManager;
+
+	public get manager(): CLLocationManager {
+		return this._manager;
+	}
+
+	constructor(manager: CLLocationManager) {
+		this._manager = manager;
+	}
+}