This is part 2 of my Ethereum/Bitcoin price tracking app tutorial. You can read part 1 here if you’d like to get caught up. I wrote this tutorial so you can follow it even if you didn’t read part 1, however.

I wrote the first part of this tutorial on October 10th 2017. Since then the Bitcoin price has gone from $4,805 to $16,764 (as of December 21st, 2017) over a 348% increase!

I would say now is a great time to add Bitcoin support to our price tracker. Now that we’ll be adding a second currency it’d be nice to make our solution scalable to many currencies. When we’re done the app will look like this:

Lets jump right in. Download the starter project here then open “CryptoTracker.xcodeproj”. You’ll need Xcode 9 to open it up since the project is built in Swift 4.

Open up “Assets.xcassets” from the projects pane on the left-hand side, then expand the “Currencies” folder. You’ll see the project already has logos for the six currencies we’ll be supporting in this tutorial.

Now, select “Main.storyboard” from the projects pane and you’ll see a UITableViewController with an embedded UITableViewCell. Expand from the left-hand panel “Crypto Table View Controller Scene → Crypto Table View Controller → Table View →CryptoTableViewCell →Content View” then select CryptoTableViewCell. From there you should tap the “Connections Inspector” which is the last button on the top right in the panel on the right-hand side. (Looks like an → symbol inside a circle):

The Table View is of type CryptoTableViewController and the cell is of type CryptoTableViewCell. These correspond to those two files within the projects pane. The cell has 3 subviews. The first is a UIImageView which will show the icon for a currency, named currencyImageView. The bold text that says “Cryptocurrency Name” is a UILabel named currencyName. The text underneath that that says “$0.00” will show our price in USD, named currencyPrice.

Open up “CryptoTableViewCell.swift” and you’ll see it has @IBOutlet’s for the currencyImageView, currencyName, and currencyPrice. This is connected to the UIImageView, and two UILabels we just looked at in “Main.storyboard”.

A data model for Cryptocurrencies

Now its time to start adding support for some Cryptocurrencies. Create a new file (⌘+n), select “Swift File” as the type and click next in the bottom right. In the “Save as” prompt name the file “CurrencyType” and click “Create” in the bottom right of the prompt.

Add the following enum on line 10 of the new file:

CurrencyType is an enum which we will use to represent six different Cryptocurrencies, Bitcoin (BTC), Ethereum (ETH), Litecoin (LTC), Ripple (XRP), Monero (XMR), and NEO (NEO). Its a String type enum so if you try to read its rawValue it will return the String its associated with. For instance, CurrencyType.btc.rawValue returns the String “BTC”.

In part 1 we used the CryptoCompare API to get the price of Ethereum by performing a GET request at the following URL:

let apiURL = URL(string: “https://min-api.cryptocompare.com/data/price?fsym=ETH&tsyms=USD")

Our enum cases have a rawValue associated with them mapping to each of the six Cryptocurrencies. We can use that to modify this URL to get the value for each of them. To do so hit enter on line 17 then add the following on line 18 of the file:

By leveraging the rawValue we can now get the respective URL for any Cryptocurrency we add to the CurrencyType enum. For exampleCurrencyType.btc.apiURL returns the URL:

https://min-api.cryptocompare.com/data/price?fsym=BTC&tsyms=USD

Going to this URL will get back the BTC price in USD.

Now to display the name of these currencies within the cell, we create a variable called name. Add the following to line 23 underneath the apiURL var:

This will allow us to get the name back for a CurrencyType as a String. For instance, CurrencyType.xrp.name will return the String “Ripple”.

Next, we’ll want to be able to get the image for each of the currencies icons. To use the UIImage API we must first import UIKit, to do that replace import Foundation on line 9 with the following:

import UIKit

Now that we can use UIImage's API lets create a var called image by adding this on line 40:

#imageLiteral extracts the image with the specified resourceName seen above from the “Assets.xcassets” catalog we looked at earlier. It returns a guaranteed non-nil image since the name maps with that image’s name within the Asset catalog. If you try deleting #imageLiteral(resourceName: "Bitcoin") above and start typing the word “Bitcoin” you should be able to select the “Bitcoin” #imageLiteral from autocomplete:

And now we have an icon and a name for each of our Cryptocurrencies. Next step is to actually be able to get the current value for each of these. For this, we need to make a GET request to the CryptoCompare API.

Recall earlier that we already have a var called apiURL which maps to the correct URL for each of our currencies prices. We can use that URL to make a request to the API and store the price as a String. Add the following func on line 58 that we’ll use for this request:

Our requestValue function has a completion block which will return an NSNumber?. We are using a completion block here because a URLRequest is a background operation, meaning that the UI work of rendering the app occurs while the function is operating. Once this function completes its work in the background we can use the value var it gets back on the main thread through a completion handler.

The first step in the function is to safely unwrap apiURL, recall earlier that the type of apiURL was URL? so to use it for requests it must be unwrapped first. Our guard statement does that and gives us an apiURL instance of type URL.

Now lets start the request. Hit enter on line 64 then add this on line 65:

First, we perform a dataTask request that takes in the URL, using Apple’s URLSession API. It returns Data from the call, a response(which returns information about the call), and an optional Error in the event of failure.

We do request.resume() at the end which starts the call. At this point, we are not doing anything with the information returned. Let’s replace the TODO with the following:

This confirms that the data we got back isn’t nil and that there weren’t any errors. In the else case we send back nil since no data was found and try to print the Error, for safety we unwrap it using ? to get back a description of the Error and if no description is found we print an empty String. The Error should never be nil here but using optionals is a good habit to get into for writing safe code.

Now we have the Data safely unwrapped and made sure there aren’t any errors, now its time to fetch the USD value from the JSON response we got back from the server. To do so add the following on line 71 underneath the guard block we just added:

To read the JSON Data, we use the JSONSerialization class from Apple, which takes JSON Data and converts it into a Dictionary. Since this method throws an Error in the case of failure, we need to add do at the beginning and catch to handle errors.

Once we have the Dictionary we can start reading values, inside the JSON Dictionary is the key “USD” which contains the US price of the currency as a number so we cast that value to NSNumber.

If for whatever reason we can’t get back the value we pass nil to the completion block again and return. If we do get the value back safely though we pass it to the completion block.

Setting up our cell to display Cryptocurrencies

Alright, now that the CurrencyType stores a name, image, and value for each of our currencies we can now use it in our CryptoTableViewCell, open up “CryptoTableViewCell.swift” from the projects pane on the left-hand side.

To display the value we get back from the requestValue function we need a way to format the value as US currency. Let’s write a private extension for NSNumber to do this. Add the following on line 18 of the file underneath the CryptoTableViewCell:

By making this an extension of NSNumber we can access the var from an NSNumber instance.

The formattedCurrencyString uses NumberFormatter, a class from Apple that takes numbers and represents them in various text formats. By setting the locale to en_us and the numberStyle to .currency we can use the NumberFormatter to represent the value in US dollars.

We then use the NumberFormatter’s string(from:) method by passing in self which is our instance of NSNumber. This returns an optional String? instance formatting the number as US dollars.

Now let’s take care of formatting our cell with the CurrencyType data model. To do so we need to set the currencyImageView, currencyName, and currencyPrice with the values from a CurrencyType instance. Add the following on line 16 right under those 3 @IBOutlets:

formatCell is a function that takes in a CurrencyType instance, sets the text for currencyName equal to currencyType.name and the image for currencyImageView equal to currencyType.image. It also performs the requestValue function to fetch the value of the currency.

requestValue has a completion block which returns with an instance of NSNumber? which either holds the value of the currency or nil. This happens in the background so we use Apple’s Dispatch API to set the text for currencyPrice on the main thread using DispatchQueue.main.async.

Since value is optional we can unwrap it as value? and then get the US currency String using the formattedCurrencyString variable we wrote. Since this operation could return nil we handle the failure case using the ?? operator. ?? means if value?.formattedCurrencyString is nil it will return whats on the right-hand side instead.

In this case, we return the String “Failed to get price”. It’s a good idea when working with API’s to assume errors can happen, and to handle these without force unwrapping using ! which would crash the app if one of our currency API calls failed.

Populate the table view with our Cryptocurrencies

Now that the cell is able to display a Cryptocurrency we need to hook up the CryptoTableViewController to pass in some CurrencyType instances to display. Open up “CryptoTableViewController.swift” then add the following on line 12:

The currencies Array stores an instance of each of the six Cryptocurrencies we support. reuseIdentifier is a String describing CryptoTableViewCell.self which will return the name of the class “CryptoTableViewCell”. The reuseIdentifier will be used when we dequeue CryptoTableViewCell instances later on.

Next, let’s implement numberOfRowsInSection which tells the UITableView how many rows we will display. This should be equal to the number of currencies. To do so hit enter under the reuseIdentifier then add the following on line 15:

currencies.count returns the number of items in the currencies array, which is six.

Now let’s populate the cells with our currencies. To do so we will be using the cellForRowAtIndexPath method. Hit enter on line 18 then add the following on line 19:

cellForRowAtIndexPath expects back an instance of UITableViewCell which is ready to be displayed. We use the UITableView function dequeueReusableCell which uses the reuseIdentifier and the current IndexPath to get an instance of our CryptoTableViewCell.

Since dequeueReusableCell returns CryptoTableViewCell as its super class UITableViewCell we have to then cast our tableViewCell instance as a CryptoTableViewCell. From there we can call the formatCell function we wrote to actually populate the cell with the CurrencyType for the current row, which we get back by using currencies[indexPath.row].

Finally, we return the tableViewCell instance so the UITableView can prepare to display it.

Giving it a test drive

Now that everything is set up let’s try running the app (⌘+R). You should see six cells populate our table view like this:

Finishing Touches

The app looks good but can be even better with a few finishing touches. By adding a header and footer to our table view we can provide a bit more info to the user.

Let’s start by adding a simple header. Hit enter on line 28 then add the following on line 29:

titleForHeaderInSection allows you to add a String that will appear above all the rows in our UITableView. Since we only have a single section we don’t need to worry about the section Int that this function provides us.

Something else that would be nice to provide users is a timestamp for when the request happened. We can put this in the footer of the table. Hit enter on line 32 then add the following to line 33 to add that:

DateFormatter is an Apple API which allows you to take a Date instance and display it in a variety of different formats. To create a simple human-readable Date we set the dateStyle to .long and the timeStyle to .medium.

We then get an instance of Date() which returns the current Date. Like NumberFormatter we use the string(from:) method to extract a String from the formatter. Finally, we add the String “Updated on ” to appear before the formatted date String.

Now run the app (⌘+R) again and it should look like this:

Conclusion

There you have it! If you had any trouble getting the app working you can download the final version here. It has some added comments and documentation as well.

Thanks so much for taking the time to read this. If this tutorial helped you I would appreciate you holding down that 👏 button below! If you’re a Github user a ⭐️ on the CryptoTracker Github page would be great too!

Cryptocurrencies like Bitcoin, Ethereum and Litecoin are exploding in value right now! In the past month (as of writing in Nov 2017), Bitcoin went from $6,100 to now $11,175, an 83% gain! Ethereum is up 65%, and Litecoin is up 81%.

Investors are eager to jump in and buy some Cryptocurrencies. This has helped Coinbase soar up the top free app charts on the App Store, it is currently the 22nd most popular app:

Before jumping into the frenzy there are a few things you should keep in mind.

Prices will drop…. Eventually

Long-term followers of this market know the price of Cryptocurrencies such as Bitcoin fluctuates all the time. Due to the current excitement around the space, it’s possible that drop won’t happen right away. It could be days, weeks, or months from now but nobody can tell you with certainty when that will happen.

Prices will bounce back after dropping

The Cryptocurrency space has lots of uncertainty which leads to tremendous volatility. A few weeks ago on November 12th, the price dropped to a low of $5,519 after hitting an all-time high of $7,776, over a 40% drop. Many investors worried that Bitcoin Cash would become the new Bitcoin and sold in a panic.

If you are not reactionary and let the fluctuations happen, good things are ahead. The blockchain technology is revolutionary. Like the early days of the Internet companies are only starting to learn about its utility and put it to use. There will be many drops and rises along that time. If you can stay on for the ride good times are ahead in 2018 and beyond.

Regarding Altcoins

Bitcoin and Ethereum are the gateways to a vibrant Cryptocurrency space. That space now has over 1,000 different coins with more entering the market daily. These coins are exciting and some of them will very likely end up being worth far more than they are today. Though it is much riskier to start with these.

My advice is to start with Bitcoin and Ethereum to get a feel for the market. If you want some Altcoins still, later on, do some research into several coins.

Put 10–20% of your Cryptocurrency portfolio in some of these projects. Try to spread that between several Altcoins instead of focusing on one to limit your risk.

Where to get started

I recommend using Coinbase, it is free to sign up and they make it very simple to get started. You will have to verify your identity and your bank account. Once you do you can start buying Cryptocurrencies right away.

It will take 5–10 days after buying a Cryptocurrency from Coinbase for it to actually appear in your account. The price that you bought it at gets locked in at the time of purchase.

Summary

• Don’t invest more than you’re willing to lose

• Start with Bitcoin, Ethereum, and Litecoin.

• Use Coinbase to get started

• Ignore short-term market fluctuations, focus on long-term goals

• If you find Altcoins you like research them. Keep these to 10–20% of your portfolio

These are exciting times in the Cryptocurrency space! People are fascinated with Cryptocurrencies and everyday investors are now jumping in. The blockchain technology is still in its infancy though and much of the innovation in the space is ahead of us.

When you want to create a trailer for your app or report a bug it’s often helpful to record your screen.

It’s ideal to be able to do this on your iPhone rather than needing other devices. iOS 11 added a new feature letting you record your screen right
from the Control Center.

The main annoyance with this feature is you can’t see where your tapping, making the video harder to follow:

But with a change in Settings, you can customize this feature to show specifically where you tap on the screen, making the video easier to follow.

To do so you’ll need two things:

1. Screen Recording added to the Control Center

2. AssistiveTouch with a custom tap gesture

Tutorial

You can follow this quick video to walk you through the process of enabling these two features:

And there you go! Now you can record your iPhone and visualize your taps. Tap the red icon on the top left to stop recording on iPhone X or the red status bar on previous iPhone models.

There are some limitations to this approach, they are as follows:

• You cannot swipe or do multitouch gestures, only single taps

• If you leave the current app and open a different one the tap indicator
  will go away.

Not perfect, but for many use cases it’s quite handy!

If this article helped you I’d love if you held down that clap button below
so more people can learn this trick.

Users love to see high app ratings when deciding which apps to download. If two apps do the same thing, but one has a higher rating than the other, which one do you think most users would choose?

Several of the most popular apps in the App Store have seen their ratings jump from the 3.5–4.5 range up to 4.8–5.0. At the same time, they’re also seeing their review count jump from 5,000–15,000 reviewers into the 100,000–1,000,000 range!

For example, let’s have a look at Instagram:

4.8 stars from over 580,000 reviewers. But Instagram is a huge app, so it’s not hard to see why so many people would have rated it.

Let’s take a look at any even larger app than Instagram — Facebook:

Facebook has a 3.0 star rating from only 14,500 users. How did Instagram get 40 times more users to rate its app when Facebook has so many more users than Instagram?

Apple’s rating prompt

The answer is the strategic placement of Apple’s native rating prompt:

Before this native solution existed, developers had to take users to the App Store to rate their Apps. Now with Apple’s solution, users can tap the rating they want, tap submit, and they’re done!

It’s available for iOS 10.3 and above — so your iOS 10 users won’t get left behind.

The prompt is very easy to add and only takes a couple lines of code:

// Add this near the top of your file
import StoreKit// Put this where you want the review prompt to appear
SKStoreReviewController.requestReview()

Making good use of the prompt

Before you jump in and paste this anywhere in your app, you need to consider your customer base. Where in your app can you show this prompt that will allow users to engage with it in a positive way?

There’s no one right answer to this question, but here are some ideas:

• For shopping apps — after one or more successful transactions.

• For content consumption apps — after a certain period of time. Or, after X number of songs/videos/books have finished.

• For social networking apps — after a user creates content. Or, when a user engages with X number of other peoples’ content.

Things to keep in mind

“Because this method may or may not present an alert, it’s not appropriate to call it in response to a button tap or other user action.”
https://developer.apple.com/documentation/storekit/skstorereviewcontroller/2851536-requestreview

requestReview() will return a prompt based on App Store policy governed by Apple. You should not present an alert beforehand asking customers if they’re enjoying your app. If you do there’s a possibility they won’t see a rating prompt resulting in a bad user experience.

“You can prompt for ratings up to three times in a 365-day period.”
— https://developer.apple.com/app-store/ratings-and-reviews/

The rating prompt will only appear to a user up to three times a year, even if they update your app.

This isn’t as much of a problem as it was in previous versions of iOS. Starting with iOS 11, Apple changed the way ratings are reset on the App Store.

In the past, every time you submitted a new build to the App Store, your ratings would get reset. Now you have the option to keep your rating history. So if you’re happy with your rating, you can keep it!

Getting a high rating on the App Store is one of the most effective ways to increase your downloads. Apple now provides an easy, native, and efficient way to boost your app’s rating. Take advantage of it in a clever way and you’ll definitely see results.

If you liked this story I would love it if you’d click the 👏 button below so more people can find out about it. Feel free to share in the responses as well if you used this prompt in your app!

Well the long rumored iPhone X is officially unveiled and it comes with a laundry list of extremely impressive specs. One of the most interesting things to note though is the new 5.8 inch “Super-Retina” display. It has a screen resolution of 1125px × 2436px. This is a particularly interesting resolution choice since according to Apple’s Human Interface Guidelines it’s an @3x screen with an effective 375 x 812 visual points of screen available.

Basically what this means for user’s is they’ll get the same content they were getting before on an iPhone 6 sized device just with 20% additional screen height and a bump from @2x resolution to @3x.

You may be thinking well what about Apple’s iPhone plus (6+, 6S+, 7+, 8+) line? Those have been “true” @3x devices for years now right? Well not quite. Following Paintcode app’s “Ultimate Guide To iPhone Resolutions” which has been updated to include the new iPhone X the 6 Plus takes a @3x effective resolution than downsamples it to fit the physical pixels on the screen.

What this means for user’s is this is the first device that they will truly see the full visual fidelity of @3x elements on their screens. For developers it means now is as good a time as an any to jump on the @3x support bandwagon. It’s likely you are already providing @2x and @3x versions of your assets though in which case you’re all set for supporting the full display capabilities of the iPhone X.

For flat/simple vector assets its recommended to bring them into Xcode as PDF’s and let Xcode scale these into 1x/2x/3x assets for you. Starting with Xcode 9 this is easier than ever to use since there is a new option to preserve vector data. That means not only can it handle scaling for different devices but your assets can be upsized or downsized without any loss in quality. To take advantage of this new feature you can follow this guide.

The iPhone X represents a significant departure from Apple’s strategy for the last couple of years of delivering iterative improvements with minimal design changes to their flagship device. What are your thoughts on supporting this device in your app’s going forward?

IOS

IPhone

Xcode

Vector

When doing the front end for our iOS applications we often have to initialize colors. You’ve probably written a lot of code that looks like this in your classes:

Writing this over and over again can become incredibly tedious. When developing a large scale iOS application you may be initializing colors in this manner dozens of times.

Enter Convenience Initializers

Like with many technical problems in Swift we do have a simpler solution, the convenience initializer.

What it does essentially is allow you to call an existing initializer with your own set of parameters. Heres one example to make our UIColor’s a tad bit easier to initialize:

And now we can initialize our colors from before like this:

Ahh, much better, no more dividing by 255 every time! Also, by shrinking the commonly understood words red, green, and blue to r, g, and b we have a much more simple initialization. But we can enhance this a bit more.

Tightening up our solution

This works but we can do more. What if we don’t want to keep writing alpha 1.0 over and over when most of our colors are 100% alpha? Lets make that an optional parameter:

Now we can initialize with either an alpha value of our choice or if its supposed to be 100% we don’t need to fill in alpha at all.

This is better but I think its important we try to write our code with as little repetition as possible. Casting 3 integers to CGFloat and dividing each by 255 seems silly when we can write a little inline function to do that task:

Our new inline function takes our int value, casts it to CGFloat, divides it by 255 and returns the CGFloat value we need for each of the corresponding red, green, and blue values.

Now if Apple decides to change the way UIColor’s are initialized in later versions of Swift instead of updating that functionality in 3 places we have one method where we can take care of things.

Lets take a look at how we can initialize our 3 colors now:

Much, much shorter than the initializer we started with! You can use these same principles to simplify other initializers throughout UIKit or even your own classes.

You can find the full source code for this tutorial on my github here:

https://github.com/allgamesallfree/convenient-uicolors

Ethereum, Bitcoin, and cryptocurrencies at large have been exploding in value lately. Even if you’re not invested in cryptocurrencies yourself now is a great time to learn how to program apps that leverage them.

Today we will be building a very simple Ethereum/Bitcoin price tracker in Swift 4 using Xcode 9. To get started download the base project here then open “CryptoTracker.xcodeproj”.

Try running the app (⌘+R) in the iOS Simulator and you’ll notice the text “$0.00” with “Ethereum Price” under it. If you select “Main.storyboard” from the projects pane on the left-hand side you’ll see we have a horizontally and vertically aligned stack view with the two labels. Select the “$0.00” label and reveal the connections inspector (⌘+⌥+6) and you’ll see it has a @IBOutlet connection to “ViewController.swift” with the name etherValueLabel. We will edit this label with the real value of the currency later.

Getting Connected

Our price tracker wouldn’t be very good without up to date information on prices. The best way to get this information is through the use of an API, and CryptoCompare has a great one that supports numerous types of currencies.

For now, we want to use it to make an API call to get back Ethereum’s price in USD so we can display that in our app. Open up “ViewController.swift” from the projects pane and add the following below the etherValueLabel @IBOutlet at the top of the file:

let apiURL = URL(string: "https://min-api.cryptocompare.com/data/price?fsym=ETH&tsyms=USD")

This is the API URL we will be connecting to in order to fetch the data we now read to write a GET request in order to retrieve the latest price information from this URL. Add the following function below the didReceiveMemoryWarning function:

Our function takes in a URL and has a completion block which returns an optional value. We will send this information back later when we complete our request or send back nil if there is an error.

On the first line, we perform a basic dataTask request that takes in the URL, this is done using Apple’s URLSession API. It returns data from the call, a response(which returns information about the call that was made), and an optional error in the event of failure.

We also do request.resume() at the end which actually starts the call. Up to this point though we are not doing anything with the information returned from the call, so replace the TODO with the following:

This confirms that the data we got back isn’t nil and that there weren’t any errors. In the else case we send back nil since no data was found and try to print the error, for safety we unwrap it using ? to get back a description of the error and if no description is found we just print an empty String. The error should never be nil in this case but using optionals is a good habit to get into for writing safe code.

Now we have the data safely unwrapped and made sure there aren’t any errors, now its time to fetch the USD value from the JSON response we got back from the server. To do so add the following underneath the guard block we just added:

In order to read the JSON data in Swift, we use the JSONSerialization class from Apple, which takes JSON data and converts it into a dictionary which can be read in Swift. This must be done using a Swift try-catch block, which is why we need to add do at the beginning and catch to handle an error in the case that we aren’t able to get back the JSON data.

Once we have the dictionary we can start reading values, inside the JSON dictionary is the key “USD” which contains the US price of Ethereum as a number so we cast that value to NSNumber.

If for whatever reason we can’t get back the value we pass nil to the completion block again and return. If we do get the value back safely though we pass it to the completion block.

Next, we’ll write a small helper function that takes the value number and formats it to a US currency string. Add the following underneath the makeValueGetRequest function we just wrote:

NumberFormatter is a class from Apple that takes numbers and represents them in various text formats. By setting the locale to en_us and the numberStyle to .currency we can use the NumberFormatter to represent the value in US dollars.

Now we need to unwrap the value passed into the formatAsCurrencyString function to ensure it’s not nil and format it using the NumberFormatter instance we just created.

We unwrap the value using a guard and use the NumberFormatter string function which takes a NSNumber and converts it to a String following the formatter’s rules (which here was that we print a currency style String using US values). At the end, we return the formattedCurrencyAmount String which we can use to print that value on the screen.

Great! Now we can get a numerical value back from the API and we can format that value into US dollars. All that we have to do now is make the request and populate the on-screen etherValueLabel with the value.

Recall that in the beginning, we added the following line to store the URL for the CryptoCompare API:

let apiURL = URL(string: "https://min-api.cryptocompare.com/data/price?fsym=ETH&tsyms=USD")

Now we want to use that URL to make a GET request for the data. Before we can use that URL though we first have to unwrap its value. By default, URL objects initialized with a String are optional since the URL could potentially return nil if the String resolves to an invalid web address.

To do so add the following under super.viewDidLoad() in your viewDidLoad function:

A quick, simple guard statement ensures apiURL on the left-hand side is safely unwrapped and ready to be used to fetch that data.

Recall that earlier we created the makeValueGETRequest function which takes in a URL and has a completion block that returns the value of Ethereum as a number.

We can pass in the now unwrapped apiURL then we can use that formatAsCurrencyString function to convert that value to a String in US dollar currency format. Finally, we can display that String on the etherValueLabel so the user’s of our app can see it.

We call the makeValueGETRequest function we created earlier with our now unwrapped apiURL and get back value in NSNumber format which represents the cost of 1 ETH in US dollars.

For the next part, we have to use a DispatchQueue, a class provided by Apple to deal with multithreading. The makeValueGETRequest performs the GET request in the background so that it won’t interrupt the main thread, which is used by iOS to update the UI on the screen. By doing this work in the background we can avoid interrupting any interface changes with our GET request.

To get back to the main thread using DispatchQueue we use DispatchQueue.main.async a method that creates a block where we can update the UI on the main thread after coming back from a background operation.

Once inside we assign the etherValueLabel.text with our value for 1 ETH in US dollars. The ?? after the formatAsCurrencyString is known as nil coalescing which means since formatAsCurrencyString returns an optional String (either the US dollars value or nil in the case of a failure), the ?? acts as an OR clause essentially which in the case of failure will simply print the String “Failed” to the user.

Whenever you’re dealing with API’s it’s always good to handle failure gracefully, there are many ways to do so and the nil coalescing operator is certainly a handy tool to keep in mind.

Try running the app (⌘+R) and you should now see the value of 1 ETH!

Whats Next?

You can download the final version of this project with some added comments here.

Update: part 2 is out now! Go check it out to learn how to build a more robust price tracker with Bitcoin, Ethereum, Litecoin, Monero, Ripple, and NEO support!

One thing that nearly all developers have to deal with when writing iOS applications is writing code that’s only intended to run on a particular iPhone model.

This is especially true of Apple’s new iPhone X which has a significantly taller, higher resolution display than past devices, with a notch at the top and enlarged areas at the top and bottom.

In order to make it much easier to write code that only runs on the model’s you specify I created ScreenType.

If you use Cocoapods you can install ScreenType by adding the following line to your podfile:

pod 'ScreenType'

It can also be installed manually by importing ScreenType.swift into your project.

How it works

ScreenType is an enum with cases for all iPhone models ranging from iPhone 4 all the way up to iPhone X, as well as all iPad models including Apple’s new 10.5-inch iPads. It’s an Int type enum so we can do comparisons between ScreenType’s as you’ll see in the usage examples below.

ScreenType also stores the value current as an extension to Apple’s UIScreen class as a static var. It gets the current screen type by comparing the longest side of the running device’s screen to the sizes of each iPhone and iPad model and returning the matching device.

For instance, the iPhone 4 has a screen that is 480pt’s tall so if the running device’s height is 480 than current will return a ScreenType of iPhone4. By calling UIScreen.current you can make comparisons easily between the running device and any iPhone / iPad model’s you would like.

ScreenType in Action

Here’s an animation of what the ScreenType sample project displays when launching on iPhone 8, iPhone X, and iPhone 8 Plus simulators, respectively:

Usage

If you’re using Cocoapods be sure to add the following line to the top of your Swift files prior to using ScreenType:

import ScreenType

The first and most obvious usage is a direct comparison of UIScreen.current and a specific model:

This can be used anywhere in your app you’d like to do something only on a specific device.

You can also use a simple OR operator to do things for two or more types of devices:

If you need to do specific things for all devices above or below a certain size, you can compare the current ScreenType with another using less than and greater than:

What about Objective-C?

Objective-C natively maps over Swift Int enums so long as you have a bridging header. That means the ScreenType enum can be used in Objective-C just as easily as in Swift.

If you’re using Cocoapods don’t forget to add @import ScreenType; to your file as well.

Once thats all set checking the current device in Objective-C is very simple:

You can also do comparisons against the raw Int value just like in Swift

There are many other ways you can use this enum to do comparisons between various devices. You can download a full sample app, get installation instructions and more on the ScreenType Github page.

If ScreenType help’s you then a ⭐️ on Github would be greatly appreciated! Also, if you liked this story I would love if you’d click the 👏 button below so more people can find out about it.