iOS Developers

Swipe Table View Cell for Custom Actions iOS Tutorial with Swift 3

Read

The UITableViewRowAction class can be used to create custom actions to the rows of a Table View. In this Tutorial a rate and share action will be added to the Table View row. This tutorial is made with Xcode 9 and built for iOS 11.

Open Xcode and create a new Single View App.

For product name, use IOS11ActionsTableViewTutorial and then fill out the Organization Name and Organization Identifier with your customary values. Enter Swift as Language and choose Next.

Go to the storyboard. Remove the View Controller from the Storyboard and drag a Navigation Controller to the Scene. This will also add the Table View Controller. Select the Navigation Controller and go to The Attribute inspector. In the View Controller section check the "Is Initial View Controller" checkbox.

Select the Table View Cell and go to the Attributes Inspector. In the Table View Cell section set the Identifier to "Cell".

The storyboard will look like this.

Since the View Controller is removed from the Storyboard the ViewController.swift file can also be deleted from the project. Add a new file to the project, select iOS->Source->Cocoa Touch Class. Name it TableViewController and make it a subclass of UITableViewController.

The TableViewController class needs to be linked to The Table View Controller object in the Storyboard. Select it and go the Identity Inspector. In the Custom Class section change the class to TableViewController.

Go to TableViewController.swift and create an array containing the table data.

let apps = ["Minecraft","Facebook","Tweetbot","Instagram"]
 
he TableViewController class contains some boilerplate code. 
Change the following delegate methods   

override func numberOfSections(in tableView: UITableView) -> Int {
    // 1
    return 1
}
override func tableView(_ tableView: UITableView, numberOfRowsInSection section: Int)

         -> Int {
    // 2
    return apps.count
} 
override func tableView(_ tableView: UITableView, cellForRowAt indexPath: IndexPath)

         -> UITableViewCell {
    // 3
    let cell = tableView.dequeueReusableCell(withIdentifier: "Cell", for: indexPath)
    cell.textLabel?.text = apps[indexPath.row]

    return cell
}

There is only one section in the Table View so 1 needs to be returned in the numberOfSections(in:) method.
The number of rows is equal to the number of items in the apps array so the count property of the array class is used.
The name of the app at the current index of the apps array is assigned to the text property of the textLabel property of the current cell.

Build and Run the project. The rows should be filled with the app's names.

To enable the custom actions when the user swipes on the Table View Cell, the tableView(_:editActionsForRowAt:) must be implemented.

override func tableView(_ tableView: UITableView, editActionsForRowAt indexPath: IndexPath) -> 
           [UITableViewRowAction]?
{
    // 1
    let shareAction = UITableViewRowAction(style: UITableViewRowActionStyle.default, title: "Share" ,
               handler: { (action:UITableViewRowAction, indexPath: IndexPath) -> Void in
    // 2
    let shareMenu = UIAlertController(title: nil, message: "Share using",
                preferredStyle: .actionSheet)
            
    let twitterAction = UIAlertAction(title: "Twitter", 
                style: UIAlertActionStyle.default, handler: nil)
    let cancelAction = UIAlertAction(title: "Cancel", style: UIAlertActionStyle.cancel,
            handler: nil)
            
    shareMenu.addAction(twitterAction)
    shareMenu.addAction(cancelAction)
            
    self.present(shareMenu, animated: true, completion: nil)
    })
    // 3
    let rateAction = UITableViewRowAction(style: UITableViewRowActionStyle.default,
          title: "Rate", 
          handler: { (action:UITableViewRowAction, indexPath:IndexPath) -> Void in
    // 4
    let rateMenu = UIAlertController(title: nil, message: "Rate this App", 
          preferredStyle: .actionSheet)
            
    let appRateAction = UIAlertAction(title: "Rate", 
             style: UIAlertActionStyle.default, handler: nil)
    let cancelAction = UIAlertAction(title: "Cancel",
             style: UIAlertActionStyle.cancel, handler: nil)
            
    rateMenu.addAction(appRateAction)
    rateMenu.addAction(cancelAction)
             
    self.present(rateMenu, animated: true, completion: nil)
  })
    // 5
    return [shareAction,rateAction]
}

A TableViewRowAction defines the Share action to present
An Alert Controller is presented with the Twitter and cancel actions
A TableViewRowAction defines the Rate action to present
An Alert Controller is presented with the Rate and cancel actions
This method returns an array of UITableViewRowAction objects.

Build and Run the project and swipe to see the custom defined actions.

You can download the source code of the IOS11ActionsTableViewTutorial at the ioscreator repository on Github

Multiple Firebase Environments in iOS

By Manish Chauhan

Read

0 Comments

Introduction

The Firebase suite of products is great for getting basic mobile backend services up and running quickly. One of the most common Firebase services is Google Analytics for Firebase, which allows you to setup and track actions that users are performing in your app. The deeper you invest in setup of analytics events, the more accurately you can start to understand user behavior and react appropriately. Sometimes, this might mean making business-critical decisions based on this information, which makes the accuracy of said information of upmost importance. In this post, we’ll talk about the potential negative consequences of failing to prevent this “data pollution”. Then, we’ll go through the process of setting up your Xcode project to enable separate Firebase development and production environments.

Data Pollution

One potential source of pollution to your analytics data could be from your own QA process when developing and testing your app. If analytics data capture is not suppressed during the testing process, then your testers could be over-exaggerating certain user flows, giving you a false image of how your actual users are actually using the app. Sure, you could probably work around this by setting up some clever rules to try and filter out the invalid data before analysis, but wouldn’t it be better if the data never made it into your production environment in the first place?

Another source of pollution could live in the Firebase Analytics console itself. During the development process, you may want to experiment with setting up new funnels, audiences, or filters in response to the creation of new analytics events or application features. In this case, suppressing the analytics events would prevent you from being able to do proper prep-work inside the console. You also don’t want to pollute your production Firebase Analytics console with fragments and configurations leftover from your development and testing process.

Separate Firebase Environments — Existing Solutions

Surprisingly, setting up separate Firebase development and production environments isn’t very well documented, and some popular techniques could have unintended consequences.

One of the first results when you may come across when researching a solution involves creating two separate Firebase projects, which ultimately yields two separate GoogleService-Info.plist files. It’s then recommended to bring these both into your Xcode project, renaming the file that corresponds to your development Firebase environment with a “-Dev” suffix. A compilation condition check is then implemented in the code to manually start up the Firebase SDK with the contents of the appropriate GoogleService-Info.plist file.

It’s important to note that this approach will work. The Firebase iOS documentation even recommends it when setting up a single app target to work with multiple Firebase environments. However, the Firebase documentation also warns developers that utilizing this approach can impact analytics collection in some circumstances. This is due to the fact that the Firebase SDK collects events very early in the application launch flow, in some cases before the primary Firebase app instance has been configured. In this scenario, the SDK uses the default name of the configuration file — GoogleService-Info.plist — to log these events. This means that the SDK could potentially be using the wrong configuration file briefly before your code is given a chance to configure the Firebase instance properly.

In most cases, this drawback probably will not pose any issues to your app. Firebase has explained the caveats to this approach in their documentation. However, even if your app won’t be affected by the potential drawbacks, you may want to go ahead and setup your project so that it removes the risk of them ever potentially becoming an issue.

Separate Firebase Environments — An Alternate Approach

The first few steps of the current approach to setting up separate development and production Firebase environments are correct. To start off, you’ll still want to:

1. Create two separate Projects (not Apps), configuring each one to use the Bundle ID for your app target in Xcode.

2. In the Firebase console, create an iOS App for each Firebase project.

3. In the Firebase console, download the GoogleService-Info.plist for each app, saving them to separate directories on your hard drive.

For this setup process, instead of renaming one of the files to GoogleServices-Info-Dev.plist, we’ll keep the name of the configuration files to their default of GoogleService-Info.plist. This is to prevent us from having to manually configure the Firebase SDK instance during the app launch process, which will prevent the potential caveats with this approach from ever coming into the picture. To keep the default names for the plist configuration files, we’ll need to keep them in separate directories on the file system:

4. Inside of the directory corresponding to your app target’s code (usually the same directory that contains your AppDelegate.swift, Assets.xcassets, and Info.plist files), create a Firebase directory.

5. Inside of the Firebase directory, create Dev and Prod child directories.

6. Copy the GoogleService-Info.plist corresponding to your Firebase development environment into the Dev directory.

7. Copy the GoogleService-Info.plist corresponding to your Firebase production environment in the Prod directory.

This next step is optional. If you’re like me, you appreciate it when an Xcode project’s “Group” structure matches the folder structure on the file system:

8. Add the Firebase folder to your Xcode project. Since this is the parent directory, it should automatically bring in the Dev and Prod child directories and their corresponding GoogleService-Info.plist files.

9. Make sure to uncheck “Copy items if needed” and all targets under “Add to targets”.

If you accidentally add either of the GoogleService-Info.plist to your target, you can open up the Utilities Panel (right side) and uncheck the files from any targets that may be in there:

When all is said and done, your Xcode project structure should look something like this:

You may be wondering why the GoogleService-Info.plist files aren’t being added to the app target. Indeed, they do need to be present in the final app bundle so that the Firebase SDK instance can be configured correctly. When the files are part of the app target, this happens automatically. However, because both files are named the same, we wouldn’t want both of them to automatically be copied into the app bundle. Instead, we’ll copy the files manually using an Xcode Run Script Build Phase:

10. In the Xcode project navigator, select the app target. Switch to the Build Phases tab at the top, then add a New Run Script Phase.

11. Name the phase “Setup Firebase Environment GoogleService-Info.plist”, or something to that effect, and place it after the Link Binary with Libraries step.

12. Implement a shell script that will copy the appropriate GoogleService-Info.plist into the app bundle based on the build configuration. Copy and paste the following shell script into the run script phase you just created:

You may need to tweak the script for your own project. The script assumes that you have the default “Debug” and “Release” configurations in your project. The production GoogleService-Info.plist will be used for “Release” builds and the development GoogleService-Info.plist will be used for all other build configurations.

13. Follow the Firebase SDK setup instructions to add the Firebase SDK to your project if it’s not already been added. Skip the step to add the GoogleService-Info.plist to your project since you’ve already done that. Also, don’t forget to initialize the SDK in your AppDelegate application:didFinishLaunchingWithOptions: method.

14. Check to make sure everything works properly:

Build your app and ensure the build process finishes without any errors. Then, right-click on the .app file in the Products group in Xcode and select Show in Finder:

Then, in Finder, right-click the .app file and select Show Package Contents:

If all went well, you should see a GoogleService-Info.plist. Open it up and verify that the values match that of your development GoogleService-Info.plist.

Next, perform some final validation to make sure your production GoogleService-Info.plist will be used for “Release” build configurations. Change your Run scheme to “Release” and build your app again.

Crack open the .app again and verify that the GoogleService-Info.plist matches your production version. At this point, you should be good to go. Don’t forget to change your Run scheme back to “Debug” before you actually run your app and continue development.

Conclusion

That’s it! Your Xcode project is now configured to swap out your GoogleService-Info.plist based on build configuration. This will keep all of your development and production Firebase Analytics data separate so that you won’t have to worry about polluting your production analytics data when developing or testing debug versions of your app.

If you’d like to see all of the pieces in action, a fully configured sample project is available on GitHub. The latest version of the shell script used to selectively copy the GoogleService-Info.plist is also available as a GitHub Gist. At the time of writing, the following tools were used to generate this guide:

Xcode 8.3.3
Cocoapods 1.3.0.beta.2
Firebase iOS SDK 4.0.3

iOS Developers

Swipe Table View Cell for Custom Actions iOS Tutorial with Swift 3

Multiple Firebase Environments in iOS

Recent Posts

Facebook

Report Abuse

About Me

What is new in Swift 4

Followers

Archive

Search This Blog

Archive

Labels

Blog Post

Video Of Day

Like This Theme

Author Info