1 files changed, 209 insertions, 74 deletions

diff --git a/src/location-corelocation.m b/src/location-corelocation.m
index 2f1768d..10d7acd 100644
--- a/src/location-corelocation.m
+++ b/src/location-corelocation.m
@@ -14,7 +14,7 @@
    You should have received a copy of the GNU General Public License
    along with Redshift.  If not, see <http://www.gnu.org/licenses/>.
 
-   Copyright (c) 2014  Jon Lund Steffensen <jonlst@gmail.com>
+   Copyright (c) 2014-2017  Jon Lund Steffensen <jonlst@gmail.com>
 */
 
 #ifdef HAVE_CONFIG_H
@@ -25,9 +25,11 @@
 #import <CoreLocation/CoreLocation.h>
 
 #include "location-corelocation.h"
+#include "pipeutils.h"
 #include "redshift.h"
 
 #include <stdio.h>
+#include <unistd.h>
 
 #ifdef ENABLE_NLS
 # include <libintl.h>
@@ -37,128 +39,261 @@
 #endif
 
 
-@interface Delegate : NSObject <CLLocationManagerDelegate>
+typedef struct {
+  NSThread *thread;
+  NSLock *lock;
+  int pipe_fd_read;
+  int pipe_fd_write;
+  int available;
+  int error;
+  float latitude;
+  float longitude;
+} location_corelocation_state_t;
+
+
+@interface LocationDelegate : NSObject <CLLocationManagerDelegate>
 @property (strong, nonatomic) CLLocationManager *locationManager;
-@property (nonatomic) BOOL success;
-@property (nonatomic) float latitude;
-@property (nonatomic) float longitude;
+@property (nonatomic) location_corelocation_state_t *state;
 @end
 
-@implementation Delegate;
+@implementation LocationDelegate;
 
 - (void)start
 {
-	self.locationManager = [[CLLocationManager alloc] init];
-	self.locationManager.delegate = self;
+  self.locationManager = [[CLLocationManager alloc] init];
+  self.locationManager.delegate = self;
+  self.locationManager.distanceFilter = 50000;
+  self.locationManager.desiredAccuracy = kCLLocationAccuracyKilometer;
+
+  CLAuthorizationStatus authStatus =
+    [CLLocationManager authorizationStatus];
+
+  if (authStatus != kCLAuthorizationStatusNotDetermined &&
+      authStatus != kCLAuthorizationStatusAuthorized) {
+    fputs(_("Not authorized to obtain location"
+            " from CoreLocation.\n"), stderr);
+    [self markError];
+  } else {
+    [self.locationManager startUpdatingLocation];
+  }
+}
+
+- (void)markError
+{
+  [self.state->lock lock];
 
-	CLAuthorizationStatus authStatus =
-		[CLLocationManager authorizationStatus];
+  self.state->error = 1;
 
-	if (authStatus != kCLAuthorizationStatusNotDetermined &&
-	    authStatus != kCLAuthorizationStatusAuthorized) {
-		fputs(_("Not authorized to obtain location"
-			" from CoreLocation.\n"), stderr);
-		CFRunLoopStop(CFRunLoopGetCurrent());
-	}
+  [self.state->lock unlock];
 
-	[self.locationManager startUpdatingLocation];
+  pipeutils_signal(self.state->pipe_fd_write);
 }
 
-- (void)stop
+- (void)markUnavailable
 {
-	[self.locationManager stopUpdatingLocation];
-	CFRunLoopStop(CFRunLoopGetCurrent());
+  [self.state->lock lock];
+
+  self.state->available = 0;
+
+  [self.state->lock unlock];
+
+  pipeutils_signal(self.state->pipe_fd_write);
 }
 
 - (void)locationManager:(CLLocationManager *)manager
-     didUpdateLocations:(NSArray *)locations
+    didUpdateLocations:(NSArray *)locations
 {
-	CLLocation *newLocation = [locations firstObject];
-	self.latitude = newLocation.coordinate.latitude;
-	self.longitude = newLocation.coordinate.longitude;
-	self.success = YES;
+  CLLocation *newLocation = [locations firstObject];
+
+  [self.state->lock lock];
+
+  self.state->latitude = newLocation.coordinate.latitude;
+  self.state->longitude = newLocation.coordinate.longitude;
+  self.state->available = 1;
 
-	[self stop];
+  [self.state->lock unlock];
+
+  pipeutils_signal(self.state->pipe_fd_write);
 }
 
 - (void)locationManager:(CLLocationManager *)manager
-       didFailWithError:(NSError *)error
+    didFailWithError:(NSError *)error
 {
-	fprintf(stderr, _("Error obtaining location from CoreLocation: %s\n"),
-	       [[error localizedDescription] UTF8String]);
-	[self stop];
+  fprintf(stderr, _("Error obtaining location from CoreLocation: %s\n"),
+         [[error localizedDescription] UTF8String]);
+  if ([error code] == kCLErrorDenied) {
+    [self markError];
+  } else {
+    [self markUnavailable];
+  }
 }
 
 - (void)locationManager:(CLLocationManager *)manager
-       didChangeAuthorizationStatus:(CLAuthorizationStatus)status
+    didChangeAuthorizationStatus:(CLAuthorizationStatus)status
 {
-	if (status == kCLAuthorizationStatusNotDetermined) {
-		fputs(_("Waiting for authorization to obtain location...\n"),
-		      stderr);
-	} else if (status != kCLAuthorizationStatusAuthorized) {
-		fputs(_("Request for location was not authorized!\n"),
-		      stderr);
-		[self stop];
-	}
+  if (status == kCLAuthorizationStatusNotDetermined) {
+    fputs(_("Waiting for authorization to obtain location...\n"), stderr);
+  } else if (status != kCLAuthorizationStatusAuthorized) {
+    fputs(_("Request for location was not authorized!\n"), stderr);
+    [self markError];
+  }
 }
 
 @end
 
 
-int
-location_corelocation_init(void *state)
+// Callback when the pipe is closed.
+//
+// Stops the run loop causing the thread to end.
+static void
+pipe_close_callback(
+    CFFileDescriptorRef fdref, CFOptionFlags callBackTypes, void *info)
 {
-	return 0;
+  CFFileDescriptorInvalidate(fdref);
+  CFRelease(fdref);
+
+  CFRunLoopStop(CFRunLoopGetCurrent());
 }
 
-int
-location_corelocation_start(void *state)
+
+@interface LocationThread : NSThread
+@property (nonatomic) location_corelocation_state_t *state;
+@end
+
+@implementation LocationThread;
+
+// Run loop for location provider thread.
+- (void)main
 {
-	return 0;
+  @autoreleasepool {
+    LocationDelegate *locationDelegate = [[LocationDelegate alloc] init];
+    locationDelegate.state = self.state;
+
+    // Start the location delegate on the run loop in this thread.
+    [locationDelegate performSelector:@selector(start)
+      withObject:nil afterDelay:0];
+
+    // Create a callback that is triggered when the pipe is closed. This will
+    // trigger the main loop to quit and the thread to stop.
+    CFFileDescriptorRef fdref = CFFileDescriptorCreate(
+      kCFAllocatorDefault, self.state->pipe_fd_write, false,
+      pipe_close_callback, NULL);
+    CFFileDescriptorEnableCallBacks(fdref, kCFFileDescriptorReadCallBack);
+    CFRunLoopSourceRef source = CFFileDescriptorCreateRunLoopSource(
+      kCFAllocatorDefault, fdref, 0);
+    CFRunLoopAddSource(CFRunLoopGetCurrent(), source, kCFRunLoopDefaultMode);
+
+    // Run the loop
+    CFRunLoopRun();
+
+    close(self.state->pipe_fd_write);
+  }
 }
 
-void
-location_corelocation_free(void *state)
+@end
+
+
+static int
+location_corelocation_init(location_corelocation_state_t **state)
 {
+  *state = malloc(sizeof(location_corelocation_state_t));
+  if (*state == NULL) return -1;
+  return 0;
 }
 
-void
+static int
+location_corelocation_start(location_corelocation_state_t *state)
+{
+  state->pipe_fd_read = -1;
+  state->pipe_fd_write = -1;
+
+  state->available = 0;
+  state->error = 0;
+  state->latitude = 0;
+  state->longitude = 0;
+
+  int pipefds[2];
+  int r = pipeutils_create_nonblocking(pipefds);
+  if (r < 0) {
+    fputs(_("Failed to start CoreLocation provider!\n"), stderr);
+    return -1;
+  }
+
+  state->pipe_fd_read = pipefds[0];
+  state->pipe_fd_write = pipefds[1];
+
+  pipeutils_signal(state->pipe_fd_write);
+
+  state->lock = [[NSLock alloc] init];
+
+  LocationThread *thread = [[LocationThread alloc] init];
+  thread.state = state;
+  [thread start];
+  state->thread = thread;
+
+  return 0;
+}
+
+static void
+location_corelocation_free(location_corelocation_state_t *state)
+{
+  if (state->pipe_fd_read != -1) {
+    close(state->pipe_fd_read);
+  }
+
+  free(state);
+}
+
+static void
 location_corelocation_print_help(FILE *f)
 {
-	fputs(_("Use the location as discovered by the Corelocation provider.\n"), f);
-	fputs("\n", f);
+  fputs(_("Use the location as discovered by the Corelocation provider.\n"), f);
+  fputs("\n", f);
+}
 
-	fprintf(f, _("NOTE: currently Redshift doesn't recheck %s once started,\n"
-		     "which means it has to be restarted to take notice after travel.\n"),
-		"CoreLocation");
-	fputs("\n", f);
+static int
+location_corelocation_set_option(
+    location_corelocation_state_t *state, const char *key, const char *value)
+{
+  fprintf(stderr, _("Unknown method parameter: `%s'.\n"), key);
+  return -1;
 }
 
-int
-location_corelocation_set_option(void *state,
-				 const char *key, const char *value)
+static int
+location_corelocation_get_fd(location_corelocation_state_t *state)
 {
-	fprintf(stderr, _("Unknown method parameter: `%s'.\n"), key);
-	return -1;
+  return state->pipe_fd_read;
 }
 
-int
-location_corelocation_get_location(void *state,
-				   location_t *location)
+static int
+location_corelocation_handle(
+    location_corelocation_state_t *state,
+    location_t *location, int *available)
 {
-	int result = -1;
+  pipeutils_handle_signal(state->pipe_fd_read);
 
-	@autoreleasepool {
-		Delegate *delegate = [[Delegate alloc] init];
-		[delegate performSelectorOnMainThread:@selector(start) withObject:nil waitUntilDone:NO];
-		CFRunLoopRun();
+  [state->lock lock];
 
-		if (delegate.success) {
-			location->lat = delegate.latitude;
-			location->lon = delegate.longitude;
-			result = 0;
-		}
-	}
+  int error = state->error;
+  location->lat = state->latitude;
+  location->lon = state->longitude;
+  *available = state->available;
 
-	return result;
+  [state->lock unlock];
+
+  if (error) return -1;
+
+  return 0;
 }
+
+
+const location_provider_t corelocation_location_provider = {
+  "corelocation",
+  (location_provider_init_func *)location_corelocation_init,
+  (location_provider_start_func *)location_corelocation_start,
+  (location_provider_free_func *)location_corelocation_free,
+  (location_provider_print_help_func *)location_corelocation_print_help,
+  (location_provider_set_option_func *)location_corelocation_set_option,
+  (location_provider_get_fd_func *)location_corelocation_get_fd,
+  (location_provider_handle_func *)location_corelocation_handle
+};