First of, I am new to iOS development, and new to swift.
I am trying to get the google cloud messaging example working for iOS.

I have setup the google cloud messaging example for iOS(Swift version) from <https://developers.google.com/cloud-messaging/ios/start?ver=swift>

I did action it with the:
`pod try Google`

I do receive a registration token, but the connect with handler section on the `applicationDidBecomeActive` section does not seem to get an error, but neither seems to be going into the connected to GCM section.
from:

```
func applicationDidBecomeActive( application: UIApplication) {
    // Connect to the GCM server to receive non-APNS notifications
    GCMService.sharedInstance().connectWithHandler({
        (NSError error) -> Void in
        if error != nil {
            print("Could not connect to GCM: \(error.localizedDescription)")
        } else {
            self.connectedToGCM = true
             print("Connected to GCM")
             // [START_EXCLUDE]
             self.subscribeToTopic()
             // [END_EXCLUDE]
        }
    })
}

```

I did look at [GCM for iOS, gcm connection handler is never called](https://stackoverflow.com/questions/32689842/gcm-for-ios-gcm-connection-handler-is-never-called) but the sections that was missing there is already included in the code samples from the `pod try`.

Here is the full AppDelegate.swift:

```
//
//  Copyright (c) 2015 Google Inc.
//
//  Licensed 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.
//

import UIKit

@UIApplicationMain
class AppDelegate: UIResponder, UIApplicationDelegate, GGLInstanceIDDelegate, GCMReceiverDelegate {

  var window: UIWindow?

  var connectedToGCM = false
  var subscribedToTopic = false
  var gcmSenderID: String?
  var registrationToken: String?
  var registrationOptions = [String: AnyObject]()

  let registrationKey = "onRegistrationCompleted"
  let messageKey = "onMessageReceived"
  let subscriptionTopic = "/topics/global"

  // [START register_for_remote_notifications]
  func application(application: UIApplication, didFinishLaunchingWithOptions launchOptions:
      [NSObject: AnyObject]?) -> Bool {
    // [START_EXCLUDE]
    // Configure the Google context: parses the GoogleService-Info.plist, and initializes
    // the services that have entries in the file
    var configureError:NSError?
    GGLContext.sharedInstance().configureWithError(&configureError)
    assert(configureError == nil, "Error configuring Google services: \(configureError)")
    gcmSenderID = GGLContext.sharedInstance().configuration.gcmSenderID
    // [END_EXCLUDE]
    // Register for remote notifications
    if #available(iOS 8.0, *) {
      let settings: UIUserNotificationSettings =
          UIUserNotificationSettings(forTypes: [.Alert, .Badge, .Sound], categories: nil)
      application.registerUserNotificationSettings(settings)
      application.registerForRemoteNotifications()
    } else {
      // Fallback
      let types: UIRemoteNotificationType = [.Alert, .Badge, .Sound]
      application.registerForRemoteNotificationTypes(types)
    }

  // [END register_for_remote_notifications]
  // [START start_gcm_service]
    let gcmConfig = GCMConfig.defaultConfig()
    gcmConfig.logLevel = GCMLogLevel.Debug
    gcmConfig.receiverDelegate = self
    GCMService.sharedInstance().startWithConfig(gcmConfig)
  // [END start_gcm_service]
    return true
  }

  func subscribeToTopic() {
    // If the app has a registration token and is connected to GCM, proceed to subscribe to the
    // topic
    if(registrationToken != nil && connectedToGCM) {
      GCMPubSub.sharedInstance().subscribeWithToken(self.registrationToken, topic: subscriptionTopic,
        options: nil, handler: {(NSError error) -> Void in
          if (error != nil) {
            // Treat the "already subscribed" error more gently
            if error.code == 3001 {
              print("Already subscribed to \(self.subscriptionTopic)")
            } else {
              print("Subscription failed: \(error.localizedDescription)");
            }
          } else {
            self.subscribedToTopic = true;
            print("Subscribed to \(self.subscriptionTopic)");
            NSLog("Subscribed to \(self.subscriptionTopic)");
          }
      })
    }
  }

  // [START connect_gcm_service]
  func applicationDidBecomeActive( application: UIApplication) {
    // Connect to the GCM server to receive non-APNS notifications
    GCMService.sharedInstance().connectWithHandler({
        (NSError error) -> Void in
      if error != nil {
        print("Could not connect to GCM: \(error.localizedDescription)")
      } else {
        self.connectedToGCM = true
        print("Connected to GCM")
        // [START_EXCLUDE]
        self.subscribeToTopic()
        // [END_EXCLUDE]
      }
    })
  }
  // [END connect_gcm_service]

  // [START disconnect_gcm_service]
  func applicationDidEnterBackground(application: UIApplication) {
    GCMService.sharedInstance().disconnect()
    // [START_EXCLUDE]
    self.connectedToGCM = false
    // [END_EXCLUDE]
  }
  // [END disconnect_gcm_service]

  // [START receive_apns_token]
  func application( application: UIApplication, didRegisterForRemoteNotificationsWithDeviceToken
      deviceToken: NSData ) {
  // [END receive_apns_token]
        // [START get_gcm_reg_token]
        // Create a config and set a delegate that implements the GGLInstaceIDDelegate protocol.
        let instanceIDConfig = GGLInstanceIDConfig.defaultConfig()
        instanceIDConfig.delegate = self
        instanceIDConfig.logLevel = GGLInstanceIDLogLevel.Debug
        // Start the GGLInstanceID shared instance with that config and request a registration
        // token to enable reception of notifications
        GGLInstanceID.sharedInstance().startWithConfig(instanceIDConfig)
        registrationOptions = [kGGLInstanceIDRegisterAPNSOption:deviceToken,
          kGGLInstanceIDAPNSServerTypeSandboxOption:true]
        GGLInstanceID.sharedInstance().tokenWithAuthorizedEntity(gcmSenderID,
          scope: kGGLInstanceIDScopeGCM, options: registrationOptions, handler: registrationHandler)
        // [END get_gcm_reg_token]
  }

  // [START receive_apns_token_error]
  func application( application: UIApplication, didFailToRegisterForRemoteNotificationsWithError
      error: NSError ) {
    print("Registration for remote notification failed with error: \(error.localizedDescription)")
  // [END receive_apns_token_error]
    let userInfo = ["error": error.localizedDescription]
    NSNotificationCenter.defaultCenter().postNotificationName(
        registrationKey, object: nil, userInfo: userInfo)
  }

  // [START ack_message_reception]
  func application( application: UIApplication,
    didReceiveRemoteNotification userInfo: [NSObject : AnyObject]) {
      print("Notification received: \(userInfo)")
      // This works only if the app started the GCM service
      GCMService.sharedInstance().appDidReceiveMessage(userInfo);
      // Handle the received message
      // [START_EXCLUDE]
      NSNotificationCenter.defaultCenter().postNotificationName(messageKey, object: nil,
          userInfo: userInfo)
      // [END_EXCLUDE]
  }

  func application( application: UIApplication,
    didReceiveRemoteNotification userInfo: [NSObject : AnyObject],
    fetchCompletionHandler handler: (UIBackgroundFetchResult) -> Void) {
      print("Notification received: \(userInfo)")
      // This works only if the app started the GCM service
      GCMService.sharedInstance().appDidReceiveMessage(userInfo);
      // Handle the received message
      // Invoke the completion handler passing the appropriate UIBackgroundFetchResult value
      // [START_EXCLUDE]
      NSNotificationCenter.defaultCenter().postNotificationName(messageKey, object: nil,
        userInfo: userInfo)
      handler(UIBackgroundFetchResult.NoData);
      // [END_EXCLUDE]
  }
  // [END ack_message_reception]

  func registrationHandler(registrationToken: String!, error: NSError!) {
    if (registrationToken != nil) {
      self.registrationToken = registrationToken
      print("Registration Token: \(registrationToken)")
      self.subscribeToTopic()
      let userInfo = ["registrationToken": registrationToken]
      NSNotificationCenter.defaultCenter().postNotificationName(
        self.registrationKey, object: nil, userInfo: userInfo)
    } else {
      print("Registration to GCM failed with error: \(error.localizedDescription)")
      let userInfo = ["error": error.localizedDescription]
      NSNotificationCenter.defaultCenter().postNotificationName(
        self.registrationKey, object: nil, userInfo: userInfo)
    }
  }

  // [START on_token_refresh]
  func onTokenRefresh() {
    // A rotation of the registration tokens is happening, so the app needs to request a new token.
    print("The GCM registration token needs to be changed.")
    GGLInstanceID.sharedInstance().tokenWithAuthorizedEntity(gcmSenderID,
        scope: kGGLInstanceIDScopeGCM, options: registrationOptions, handler: registrationHandler)
  }
  // [END on_token_refresh]

  // [START upstream_callbacks]
  func willSendDataMessageWithID(messageID: String!, error: NSError!) {
    if (error != nil) {
      // Failed to send the message.
    } else {
      // Will send message, you can save the messageID to track the message
    }
  }

  func didSendDataMessageWithID(messageID: String!) {
    // Did successfully send message identified by messageID
  }
  // [END upstream_callbacks]

  func didDeleteMessagesOnServer() {
    // Some messages sent to this device were deleted on the GCM server before reception, likely
    // because the TTL expired. The client should notify the app server of this, so that the app
    // server can resend those messages.
  }

}

```

Here is information from the logs:

```
2016-02-11 14:54:02.836 GcmExampleSwift[8484:] <GMR/INFO> App measurement v.1302000 started
2016-02-11 14:54:02.844 GcmExampleSwift[8484:] <GMR/INFO> To enable debug logging set the following application argument: -GMRDebugEnabled (see http://goo.gl/Y0Yjwu)
2016-02-11 14:54:02.845 GcmExampleSwift[8484:] <GMR/DEBUG> Debug logging enabled
2016-02-11 14:54:02.845 GcmExampleSwift[8484:] <GMR/DEBUG> App measurement is monitoring the network status
2016-02-11 14:54:02.871: GCM | Invalid key in checkin plist: GMSInstanceIDDeviceDataVersion
2016-02-11 14:54:02.900: GCM | Signing into MCS
2016-02-11 14:54:02.940 GcmExampleSwift[8484:] <GMR/DEBUG> App measurement is ready to receive events
2016-02-11 14:54:02.962: GGLInstanceID | Save InstanceID library version 1.1.6
2016-02-11 14:54:03.002 GcmExampleSwift[8484:] <GMR/DEBUG> No network. Upload task will not be scheduled
2016-02-11 14:54:03.004 GcmExampleSwift[8484:] <GMR/DEBUG> Scheduling user engagement timer
Registration Token: XXXXXXXXXXXXX
2016-02-11 14:54:03.010 GcmExampleSwift[8484:] <GMR/DEBUG> Timer scheduled to fire in approx. (s): 3600
2016-02-11 14:54:03.027 GcmExampleSwift[8484:] <GMR/INFO> App measurement enabled
2016-02-11 14:54:03.028 GcmExampleSwift[8484:] <GMR/DEBUG> Network status has changed. code, status: 2, Connected
2016-02-11 14:54:03.038 GcmExampleSwift[8484:] <GMR/DEBUG> Timer scheduled to fire in approx. (s): 2816.722655892372
2016-02-11 14:54:03.039 GcmExampleSwift[8484:] <GMR/DEBUG> Upload task scheduled to be executed in approx. (s): 2816.722655892372
2016-02-11 14:54:08.222: GCM | Successfully deleted 0 sync messages from store
2016-02-11 14:54:44.905: GCM | Signing into MCS
2016-02-11 14:55:28.909: GCM | Signing into MCS
2016-02-11 14:56:16.914: GCM | Signing into MCS
2016-02-11 14:57:12.918: GCM | Signing into MCS
2016-02-11 14:58:24.923: GCM | Signing into MCS
2016-02-11 15:00:08.927: GCM | Signing into MCS
2016-02-11 15:02:46.495 GcmExampleSwift[8484:] <GMR/DEBUG> Scheduling user engagement timer
2016-02-11 15:02:46.532 GcmExampleSwift[8484:] <GMR/DEBUG> Canceling active timer
2016-02-11 15:02:46.534 GcmExampleSwift[8484:] <GMR/DEBUG> Timer scheduled to fire in approx. (s): 3600
2016-02-11 15:02:46.535 GcmExampleSwift[8484:] <GMR/DEBUG> Canceling active timer
2016-02-11 15:02:46.536 GcmExampleSwift[8484:] <GMR/DEBUG> Logging event: origin, name, params: auto, _e, {
        "_et" = 523435;
        "_o" = auto;
    }
2016-02-11 15:02:46.551 GcmExampleSwift[8484:] <GMR/DEBUG> Event logged. Event name, event params: _e, {
        "_et" = 523435;
        "_o" = auto;
    }
2016-02-11 15:02:46.566 GcmExampleSwift[8484:] <GMR/DEBUG> Do not schedule an upload task. Task already exists
2016-02-11 15:02:56.662: GCM | Signing into MCS
2016-02-11 15:02:56.681 GcmExampleSwift[8484:] <GMR/DEBUG> Scheduling user engagement timer
2016-02-11 15:02:56.683 GcmExampleSwift[8484:] <GMR/DEBUG> Timer scheduled to fire in approx. (s): 3600
2016-02-11 15:03:38.666: GCM | Signing into MCS
2016-02-11 15:04:22.671: GCM | Signing into MCS
2016-02-11 15:05:10.675: GCM | Signing into MCS
2016-02-11 15:06:06.680: GCM | Signing into MCS
2016-02-11 15:07:18.664: GCM | Signing into MCS
2016-02-11 15:08:43.991: GCM | Signing into MCS
2016-02-11 15:11:31.996: GCM | Signing into MCS
2016-02-11 15:16:27.991: GCM | Signing into MCS
2016-02-11 15:25:39.985: GCM | Signing into MCS

```

I replaced the real regsitration token with `XXXXXXXXXXXXX`.

From the logs also notice:

`GCM | Invalid key in checkin plist: GMSInstanceIDDeviceDataVersion`

Is this normal? I could find no information about what that means?

Sending messages to the device via the GCM does work, and if you modify the sample code above to not to the check for `connectedToGCM` you are also capable of receiving topic messages.
But surely there could not be mistake in the sample code, I assume that there is something wrong with my configuration, but I am unable to figure it out. Any help would be appreciated.