DEV Community: Suryansh Mansharamani

How to add and test In-App Purchases to your iOS app!

Suryansh Mansharamani — Mon, 25 May 2020 19:31:22 +0000

In-App Purchases can end up making you tons of money with your next app…

Why In-App purchases?

If you haven’t noticed, the biggest apps in the market like Spotify and Evernote are free, which attract far more users than any paid app. What makes these apps different is that they have In-App purchases which usually far surpass any income a solo developer can accumulate with a paid app. If your incentive is to not only help others and create something that the people want, but also making a good amount of money off of it, In-App purchases are perfect for you. Here is a short, easy tutorial on how to implement In-App purchases into your next app in just 13 steps…

1) Go to App Store Connect

First, go to App Store Connect (https://appstoreconnect.apple.com/)

2) Check the Paid Apps Status

Press the Agreements, Tax and Banking button to check if you’re able to create an app with any paid components in it. If it says Active, then your fine. If the dot under status for the Paid Apps type is red, then you have to add certain information before creating this app.

3) Registering the App ID

Now we need to register the App ID (https://developer.apple.com/account/resources/identifiers/bundleId/add/) .

First, for the description, write something quite generic or just the app name. The Bundle ID will be set to explicit. The Bundle ID has to be unique, so the convention usually is the following:

If you have a website, then write com.[websitename].[appname]
If you don't have a website, then write com.[fullname].[appname]

Although the capabilities section is preset, its good practice to scroll down in the Capabilities section to check that In-App Purchases is enabled.

4) Setting the Project Info

Next, open up Xcode and create a project with the same App ID description. This is a requirement because, as you can see, the Bundle Identifier is heavily dependent on both the Product Name and the Organization identifier, which follows nearly the same form:

For those with a website, it will be com.[websitename]
For those without a website, it will be com.[fullname]

For this project, we will be using Swift and the Storyboard User Interface.

5) Adding the In-App Purchase Capability to Xcode

After successfully creating the project, go to the project file and then to the Signing and Capabilities section. For the latest version of Xcode, you will have to go to the top left corner of this section which says “+ Capability” to add a capability. After the window opens, search for the In-App Purchase capability and add it to your project.

6) Creating the New App

Now, let’s go back to App Store Connect. On the upper left corner, there will be a “+” sign, where you will have to press the New App button in order to create a new app.

7) Setting the New App Info

Upon pressing the button, the following window will pop up. Here we will select the platform, which for us, will be iOS. First, start out by entering the name of the app. Remember, the name has to be unique, and while the description was quite clear, it isn’t counted and compared to the other existing apps.

In our case, I named the app InAppPurchase 1023. The primary language is quite self-explanatory and the Bundle ID will be the same bundleID we created before for this app. The SKU is basically a unique string that won’t be displayed anywhere. I encourage following this format for the SKU:

[2 or 3 letters][00]

The 00 will then change to 01 an on as you create more apps. The user will have access to the full app, so be sure to select Full Access.

8) In-App Purchase Types

Now, let’s go to Features and then In-App Purchases. When adding an In-App Purchase, make sure to only check Non-Consumable.

While Apple explains these 4 types of In-App purchases, here is a short, easy to understand the description of them:

Consumable: You can only use this once, and once you have to use it again, then you have buy it again. This applies to games that use coins, etc.

Non-Consumable: As soon as you buy a non-consumable In-App Purchase, it will stay with you forever. This usually applies to unlocking special levels in games, premium versions of apps, etc.

Auto-Renewable Subscriptions: These are great for apps like Spotify, etc. As soon as the subscription is bought, it will keep on renewing after the desired amount of time automatically unless the user chooses to cancel the subscription.

Non-Renewing Subscription: As soon as the user buys the subscription to the app, it will not automatically renew, but the user has to renew it manually.

9) Setting the price

After pressing Create, the box below might take some time to fully process. Upon finishing, you will see a drop-down which will show the different Tiers of prices. We will go with Tier 1, so if the sandbox section of this tutorial does not work out for you, it's only going to cost you 99 cents. To save some times, copy the Product ID as will be using that later.

10) Setting up the UI

Now, let's go back to Xcode and into the Main.storyboard file. By using Cmd+Shift+L, we can search and add a UIButton to our interface.

Lets set the button horizontally and vertically in the container.

Set the width 150 and the height to 50.

After that, once again, use Cmd+Shift+L to create a Label and set its alignment constraints to be horizontally in the container.

Now, let's go to the ViewController.swift file, where will paste the ID we had copied before into a new constant called PurchaseID as a string.

To make it a little bit more neat, lets set a couple more additional constraints in terms of the y position.

Now, by holding Control and moving the label to the View Controller. Set the type to UILabel and the name to buyLabel.

Let's use the same concept for the button and name it as buyPressed.

First, import the StoreKit in order to access certain commands for the In-App Purchases ability. After the colon and then the UIVewController, use the SKPaymentTransactionObeserver.

11) Let’s start the actual programming!

Create a function called as payment queue to handle the transaction states. Now in the function viewDidLoad() we will add the SKPaymentQueue, which as described by Apple, is a “A queue of payment transactions to be processed by the App Store.”. If you aren’t that proficient with Swift, I really recommend to look at this link for further information: https://developer.apple.com/documentation/storekit/skpaymentqueue

In the paymentQueue function, we will add the true content of this tutorial into it. Use the if-else statement to see if the transaction state is purchased, and if it is, let the console print back “Transaction is successful” just to be sure and change the label of the buyLabel to the same. Now use else if to see if the transaction failed or not and change the label to “The transaction has failed.”

According to Apple, the SKMutablePayment class is “A mutable request to the App Store to process payment for additional functionality offered by your app.” We will name the constant accordingly, as transactionRequest. Within this, we will “tell Apple to recognize” the purchaseID as the productIdentifier and “add” the same transactionRequest to the SKPaymentQueue.

12) Setting up testing

Now, its time to test our app! Instead of paying to make sure it works, we have to create a “sandbox account”. To do this, let's create a fake account on google. This will be your “sandbox account” from now on. You can’t use any of your own accounts since they will be associated with an Apple ID (or have been).

After entering the data below, Google will ask for your birth date, the country you live in, and phone number. You need to type in the right phone number for this to work as you will need to verify the account. Also, do NOT add a backup email, since it will be associated with your Apple ID (in most cases).

Now, let's go back into App Store Connect and into Users and Access. To the bottom left, there will be a section in bold called “Sandbox” as shown by the image below. Press on Testers under Sandbox. Here, you will notice a blue plus icon which will allow you to create a new tester. Here, enter the required information.

13) Testing

Done!

Let's go an run your app on your device, NOT the simulator, as this won’t work if you use a simulator. First, to avoid any chances of paying (although 99 cents won’t hurt) go to Settings. In Settings, scroll down to iTunes & App Stores. Under here, you should see a “Sandbox Account” section where there should be your tester account. If it’s there, then congratulations, you did it! If it isn’t, go back to the beginning and try again.

Thank you for reading my tutorial! It means a lot, and I’m sure that others would want to see this too, so don’t forget to 👏 and follow me on Medium at: https://medium.com/@suryanshmansha

Making a Music Player with SwiftUI in 3 minutes.

Suryansh Mansharamani — Sun, 17 May 2020 18:43:30 +0000

Integrating music into your next app has never been easier.

Extensions File

First, create a new .swift file named Extensions. As you could guess by the name, we will create an extension called “Color” where we will create static constants called backgroundColor and buttonColor along with a static function named rgb, where, as you could, guess contains an rgb value. The following snippet shows my own rgb colors, but feel free to edit it and use your own!

import SwiftUI

extension Color {
static func rgb(r: Double, g: Double, b: Double) -> Color { return Color(red: r / 255, green: g / 255, blue: b / 255) }static let backgroundColor = Color.rgb(r: 21, g: 22, b: 33) static let buttonColor = Color.rgb(r: 190, g: 230, b: 100) }

Modules

Next, lets set up our modules. Since SwiftUI projects have Import SwiftUI as the default module, leave it as it is and add AVKit, which is used as, according to Apple, a framework which “provides a high-level interface for playing video content.”

import SwiftUI
import AVKit

Setting Up

Now, lets get to programming! First lets use the @State property wrapper to declare a variable called “audioPlayer” which will be equal to an implicitly unwrapped optional called AVAudioPlayer, which will be used to play the given audio.

struct ContentView: View { @State var audioPlayer: AVAudioPlayer!

Inside the “var body: some View {“ we have to start our main programming. First, we will create a ZStack which will be used for the overlapping content, and then set the background to cover the entire screen, ignoring all safe areas through the following code:

var body: some View {

ZStack { Color.backgroundColor .edgesIgnoringSafeArea(.all)

In order to create the elements in a vertical order we will use the vertical stack and then use the horizontal stack to set the background image and the main title, along with setting the background’s image to fit the entire screen via the aspect ratio command. The additional code is used for additional decorative uses.

VStack {

HStack { Text("Rain").font(.system(size: 45)).fontWeight(.bold).navigationBarHidden(true) .foregroundColor(.buttonColor).background(Image("Image").resizable() .frame(width: 900, height: 900) .aspectRatio(contentMode: .fit)

)

}

The Functionality!

Create another horizontal stack for both the play and stop button, along with an additional spacer to make the layout more appealing. Now its time for the actually functionality! What’s really nice about this project is that the only thing you need is an image for the background if you want, and nothing else for the buttons since those are already provided. To make the audio play, simply use the self.audioPlayer.play() command and set its image as a preset system name, along with a few more properties as shown by the snippet below:

HStack {

Spacer()

Button(action: {

self.audioPlayer.play()

}) {

Image(systemName: "play.circle.fill").resizable() .frame(width: 50, height: 50) .aspectRatio(contentMode: .fit) .foregroundColor(.buttonColor)

}

After adding an additional spacer, create another button with the same command for the action, except with .pause in the place of .play, along with the same exact properties as the play button.

Spacer()

Button(action: {

self.audioPlayer.pause()

}) { Image(systemName: "pause.circle.fill").resizable() .frame(width: 50, height: 50)

.aspectRatio(contentMode: .fit) .foregroundColor(.buttonColor)

}

Spacer()

}

}

}

The Sound

Similar to before, after adding an additional spacer after the HStack to define the constant sound to a certain .mp3 file, you can then apply it to the audioPlayer, hence the sound functionality (Remember to keep ContentView_Preview struct without changing a thing). You can either choose to remove the background or not based on your preference.

.onAppear {

let sound = Bundle.main.path(forResource: "rain-03", ofType: "mp3") self.audioPlayer = try! AVAudioPlayer(contentsOf: URL(fileURLWithPath: sound!)) }

}

}

That’s it! I hoped you like this tutorial on making a music player in SwiftUI! Check out the final app here: https://github.com/Millennium-X/MusicPlayerDemo

Here’s the finished product:

Thank you for reading this article!
Follow me on Medium at: https://medium.com/@suryanshmansha

Why I first started programming with Swift - and why you should too.

Suryansh Mansharamani — Thu, 14 May 2020 15:23:56 +0000

Being a person with a non-technical background, I can say that scrolling through the endless rows of technical and complex questions on Stack Overflow were nothing short of mind-boggling. Luckily, Swift took those problems away by not only making me a better iOS Developer, but a more experienced programmer. For those who don't know a lick of programming, here's why Swift is absolutely perfect of you - just as it was for me.

1) It's not complex!
Xcode, the official platform where iOS developers developer games, apps, etc. had been using Objective C as the conventional programming language for years. Unfortunately, Objective C was like most other languages, filled with certain special syntax and complex ways of doing a what is now a simple task in Swift.

Don't believe me? Writing "Hello World" is convention for those who just started programming. It's supposed to be simple and a welcoming way to introduce a programmer to the limitless possibles of programming. Objective C makes it a hell of a lot harder compared to Swift. Here's proof:

OBJECTIVE C:
NSString*str =@"HelloWorld";

NSLog(@"%@", str)

Now, SWIFT:
let str ="HelloWorld"

println("(str)")

Even if someone didn't understand what both were doing and what languages they were in, they could "swift"ly say that the second one is far easier to understand.

2) Too intimidated to head straight in by making a new project in Xcode with Swift, totally fine!

For most beginners, the concept of Storyboards, Swift UI and complex file structures can be intimidating, and that's completing fine! Xcode gives you the option to "try it out" with Swift Playground, another awesome feature in Xcode! Swift Playground it completely self-explanatory, you can write the most simple of code snippets in Swift and run it by just pressing the Play button. You don't have to worry about Simulators, devices, or anything else!

3) It's new and is always updating!

The Swift programming language released in 2014, and has been updating very frequently. A new feature includes Swift UI, where you can just drag and drop buttons, labels, etc. onto the phone simulator! If that's not enough, there is also a live view feature, where the user can see how is code is affecting the looks of the app live, while they are coding!!!

While this exactly isn't a main point, the Swift community is very warm and welcoming, with special events held annually! These includes the WWDC, or Worldwide Developers Conference along with an awesome Swift Student Challenge, where students can compete by making awesome games and interactive scenes in playground for special prizes including WWDC jackets, pins, and even tickets to WWDC (not this year, unfortunately)!!!

(Be sure to follow me on Medium at: https://medium.com/@suryanshmansha)

Image Classification in Xcode without Code!

Suryansh Mansharamani — Mon, 11 May 2020 22:56:45 +0000

If you've ever wondered how to make an image classifier that you can easily implement into your own Xcode project without writing a single bit of code, here's how!

First, let's access CreateML! Start by opening Xcode. As soon as you get to the opening screen, as shown on the image below, right click the Xcode icon and press Open Developer Tools. From there, you will get multiple choices to pick from. Select Create ML.

As you open CreateML, you will be greeted by the Finder. If you are opening a preexisting ML Model file, then you can pick from the files, but in our case, you will then go to File and then New Project as shown in the screenshot below.

Upon opening the New Project, you will see something like the image below come up. CreateML offers multiple types of machine learning platforms, including text recognition, sound identification and even an object detector! For our case, you will select the first one, which is the Image Classifier.

Go ahead and name your Project! This step is quite self explanatory.

After naming your project, you will come to this screen. As you can see, there is an option to add both training and testing data. In addition, you add additional parameters such as the number of iterations desired (how many times do you want the model to repeat itself?) along with augmentations. These help you in the training of your model in order to increase both the precision and recall rate, something we will talk about nearing the end of this tutorial.

How do you organize your data?

Organizing your data carefully is extremely important in order for the model to work properly and to increase the precision rate. As shown by the series of images below, there are certain easy steps you should follow while organizing your data. First, divide it into both testing and training data. You will be dragging and dropping both these files into CreateML later on.

The image below shows the folders inside the Training data folder. Both the training and testing data should be formatted exactly the same (at least for now at this point of the tutorial). The naming of your folders here is extremely important as it defines the class names. For example, these are my top 5 clouds I used in my Cloudifier app. I programmed my app to pull data out of this model and the model is trained to only return these class names.

Here comes the difference between testing and training data, and that is by the amount of data put in. Any naming of the images is not required, as shown below, so you can drag them into the file from your browser "raw". What's extremely important is that all the data is relevant towards the class name. In addition, the training data, should be MORE than the testing data.

Now that data organization is over with, we can start focusing on how to actually train the model. First drag and drop the training data into the Training Data section, as shown below.

After adding both the training data AND the testing data, you can then selection the amount of times you want to the model to iterate itself, along with other augmentations such as cropping, flipping, rotating, etc. For those using lower end MacBook models, I recommend steering clear from augmentations and keeping the iteration number not too low nor high for a higher chance of increasing precision rate.

Press the "Train" button with Play symbol on the upper left hand corner to run your project. This will begin the process of training which usually takes a couple of seconds to multiple hours depending on the number of data and the augmentations. You can always press the Cancel button as shown below if it doesn't work.

After both the extraction of features and the iterations process is complete, then you will begin to see a graph which models the accuracy rate for both the training and validation accuracy. The validation accuracy is used to evaluate the model's performance.

As the model graph is done graphing, you will then see a table which shows both the precision and recall rate of the data trained. Usually, having rates greater than 96% means that the data is well-trained. If somehow the accuracy is slightly less try adding other augmentations and/or decreasing and increasing the number of iterations.

The model will then automatically begin to test the testing data based on the accuracy shown by the training data, as shown by the screenshot below.

This is the step where you get your final and most important results. Here, you see the both the precision and recall rate of the testing data. Although the validation rate is slightly less in this model, keep on tweaking certain features to increase all the rates of accuracy in order to further improve your model.

After this, you can simply go to the Output file and drag the ML model as shown below into your file structure in Xcode.

That's it! I hope you liked this tutorial and will use it for your own applications! Here's the link to the orginal post on my blog (there isn't much content since I just started!): https://millenniumx.carrd.co/#machinelearning