• Learning how Kotlin and Android work together
• Setting up our development environment, Android Studio
• Learning what makes an android app
• Learning about Kotlin
• Building our very first Android app
• Deploying an Android emulator
• Running our app on an Android emulator and a real device

When Androidfirst arrived in 2008, it was a bit drab compared to the muchmore stylish iOS on the Apple iPhone/iPad. But, quite quickly, through a variety of handset offers that struck a chord with practical, price-conscious consumers, as well as those who are fashion-conscious and tech-savvy, Android user numbers exploded.

For many, myself included, developing for Android is the most rewarding pastime and business, bar none.

Quickly putting together a prototype of an idea, refining it, and then deciding to run with it and wire it up into a fully-fledged app, is such an exciting and rewarding process. Any programming can be fun – I have been programming all my life – but creating for Android is somehow extraordinarily rewarding.

Definingexactly why this is the case is quite difficult. Perhaps it is the fact that the platform is free and open. You can distribute your apps without needingthe permission of a big controlling corporation – nobody can stop you. And, at the same time, you have well-established, corporate-controlled mass markets, such as Amazon Appstore and Google Play.

It is more likely, however, that the reason that developing for Android gives such a good feeling is the nature of the devices themselves. They are deeply personal. You can develop apps that interact with people's lives, which educate, entertain, tell a story, and so on, and it is there in their pocket ready to go – in the home, in the workplace, or on holiday.

You can certainly build something bigger for the desktop but knowing that thousands (or millions) of people are carrying your work in their pockets and sharing it with friends is more than just a buzz.

No longer is developing apps considered geeky, nerdy, or reclusive. In fact, developing for Android is considered highly skillful, and the most successful developers are hugely admired, even revered.

If all this fluffy, spiritual stuff doesn't mean anything to you, then that's fine too; developing for Android can make you a living, or even make you wealthy. With the continued growth of device ownership, the ongoing increase in CPU and GPU power, and the non-stop evolution of the Android operating system itself, the need for professional app developers is only going to grow.

In short, the best Android developers – and, more importantly, the Android developers with the best ideas and the most determination – are in greater demand than ever. Nobody knows whothese future Android app developers are, and they might not evenhave written their first line of code yet.

So, why isn't everybody an Android developer? Obviously, not everybody will share my enthusiasm for the thrill of creating software that can help make people's lives better, but I am guessing that, because you are reading this, you might.

• First, the operating system itself must have full access to the hardware, which it does.
• Second, this access must be programmer-friendly and easy to use, and it is because of the Androidapplication programming interface (API).

The Android APIis code that makes it easy to do exceptional things. A simple analogy could be drawn with a machine, perhaps a car. When you press on the accelerator, a whole bunch of things happen under the hood. We don't need to understandcombustion or fuel pumps, because some smart engineer has made aninterface for us; in this case, a mechanical interface – the accelerator pedal.

For example, the following line of code probably looks a little intimidating at this stage in the book, but it serves as a good example of how the Android API helps us:

locationManager.getLastKnownLocation(LocationManager.GPS_PROVIDER)

Once you learn that this single line of code searches for available satellites in space, communicates with them in their orbits around the Earth, and then retrieves your precise latitude and longitude on the surface of the planet, it becomes easy to glimpse the power and depth of the Android API.

That code does look a little challenging, even mind-boggling at this stage of the book, but imagine trying to talk to a satellite some other way!

The Android APIhas a whole bunch of code that has already been written for us to use as we like.

The question we must ask, and the one this book tries to answer, is as follows: how do we use all this code to do cool stuff? Or, to frame the question to fit the earlier analogy: how do we find and manipulate the pedals, steering wheel, and, most importantly, the sunroof of the Android API?

The answer to this question is the Kotlin programming language, and the fact that Kotlin was designed to help programmers handle complexity, avoid mistakes, and make fast progress. Let's look deeper into Kotlin andobject-oriented programming (OOP).

Kotlin is anobject-oriented language. Thismeans that it uses the concept of reusable programming objects. If this sounds like technical jargon, another analogy will help. Kotlinenables us and others (like the Android API development team) to write code that can be structured based on real-world things, and here is the important part – it can bereused.

So, using the car analogy, we could ask the following question: if a manufacturer makes more than one car in a day, do they redesign every part for every car that comes off the production line?

The answer, of course, is no. They get highly skilled engineers to develop exactly the right components, honed, refined, and improved over years. Then, those same components are reused again and again, as well as being occasionally improved.

If you are going to be fussy about my analogy, then you can point out that each of the car's components must still be built from the raw materials using real-life engineers or robots. This is true.

What software engineers do when they write their code is build a blueprint for an object. We then create an object from their blueprint using code and once we have that object, we can configure it, use it, combine it with other objects, and more besides.

Furthermore, wecan design blueprints ourselves and make objects from them. The compilerthen transforms (manufactures) our bespoke creationinto DEX code. Hey presto! We have an Android app.

In Kotlin, a blueprintis called aclass. When a class is transformed into a real working "thing," we call it anobjector an instanceof the class.

So, some smart software engineers up at Android HQ write a desperately complex program that can talk to satellites, and as a result of this, in a single line of code, we can get our location on the surface of the planet. Nice.

Most of the Android API is written in another language (Java), but this doesn't matter to us as we have full access to the functionality (coded in Java) while using the more succinct Kotlin. Android Studio and the Kotlin compiler handle the complexities behind the scenes.

The software engineers have considered how they can make this code useful to all Android programmers who want to make amazing apps that use users' locations to do cool things. One of the things they will do is make features, such as getting the device's location in the world into a simple one-line task.

So, the singleline of code we saw previously sets in action many more lines of code that we don't see, and don't need to see. This is an example of using somebody else's code to make our code infinitely simpler.

Welcome tothe world ofOOP. I will constantly refer to OOP in every chapter, and there will be a big reveal inChapter 10,Object-Oriented Programming.

To getthings done on Android, we write code of our own, which also uses the code of the Android API. This is then compiled into DEX code, and the rest is handled by the Android device, which, in turn, runs on an underlying operating system called Linux, which handles the complex and extremely diverse range of hardware that is the different Android devices.

The manufacturers of Android devices and of the individual hardware components obviouslyknow this too, and they write advanced software calleddrivers that ensure that their hardware (for example, CPU, GPU, GPS receivers, memory chips, and hardware interfaces) can run on the underlying Linux operating system.

The DEX code (along with some other resources) are placed in a bundle of files called anAndroid application package (APK), and this is what the device needs to run our app.

The nextquestion is: where exactly does all this coding and compiling into DEX code, along with APK packaging, take place? Let's look at the development environment that we will be using.

Adevelopment environment is a term that refers to having everything you need to develop, setup and ready to go in one place.

There isan entire range of tools needed to develop for Android, and we also need the Android API, of course. This whole suite of requirements is collectively known as the SDK. Fortunately, downloading and installing a single applicationwill give us these things all bundled together. The application is called Android Studio.

Android Studio is anintegrated development environment (IDE) that will take care of all the complexities of compiling our code and linking with the Android API. Once we have installed Android Studio, we can do everything we need inside this single application, and put to the back of our minds many of the complexities we have been discussing.

So, we had better get our hands on Android Studio.

1. Visitdeveloper.android.com/studio/index.html. Click the bigDOWNLOAD ANDROID STUDIO button to proceed:
   
2. Accept the terms and conditions by checking the checkbox, and then click theDOWNLOAD ANDROID STUDIO FOR WINDOWS button:
   
3. When thedownload is complete, run the file you just downloaded. It has a name that startsandroid-studio-ide…,while the end of the name of the file will vary based on the current version at the time of reading.
4. Click theNext > button to proceed:
   
5. Leave thedefault options selected, as shown in the following screenshot, and click theNext > button:
   
6. Next, we needto choose where to install Android Studio, as shown in the following screenshot:
   

   The installwizard recommends500 MBof free space, but you probably noticed from the previous screen that 2.1 GB was suggested. However, there are even more requirements later in the installation process. Furthermore, it is much easier if you have all your Android Studio parts, as well as your project files, on the same hard drive.

   For these reasons, I recommend having at least 4 GB of free space. If you need to switch drives to accommodate this, then use theBrowse.. button to browse to a suitable place on your hard drive.

   Tip

   Note down the location that you choose.

7. When you are ready, click theNext > button.
8. In this next window, choose the folder in your start menu whereAndroid Studio will appear. You can leave it as the default, as follows:
   
9. ClickInstall. This step might take some time, especially on older machines or if youhave a slow internet connection. When this stage is done, you will see the following screen:
   
10. ClickNext >.
11. Android Studiois now installed – kind of. Check theStart Android Studio checkbox and click theFinish button:
    
12. You willbe greeted with theWelcome screen, as shown in the following screenshot:
    
13. ClicktheNext button.
14. Choose theStandard install type, as shown in the following screenshot:
    
15. Click theNext button.
16. Choosewhichever color scheme looks nice to you. I choseIntelliJ, as shown in the following screenshot:
    
17. ClickNext.
18. Now youwill see theVerify Settings screen:
    
19. Click theFinish button. Android Studio will now commence some more downloads, which could take some time.
20. WhenAndroid Studio is ready, you will have the option to run it. At this point, click theFinish button. Android Studio is most likely ready. You can leave it open if you are carrying straight on with the next section, or you can close it and then reopen it when instructed to in the next section.

Using yourpreferred file manager software, perhaps Windows Explorer, create a folder calledAndroidProjects. Make it at the root of the same drive where you installed Android Studio. So, if you installed Android Studio atC:/Program Files/Android, then create your new folder atC:/AndroidProjects.

Or, if you installed Android Studio atD:/Program Files/Android, then create your new folder atD:/AndroidProjects.

AndroidStudio and the supporting tools that we need are installed and ready to go. We are now really close to building our first app.

Now, let's look a little bit at the composition of an Android app.

As mentionedearlier in this chapter, our app will include resources, such as images, sound, and user interface layouts, that are kept in separate files from the Kotlin code. We will slowly introduce ourselves to them over the course of the book.

They will also include files that have the textual content of our app. It is convention to refer to the text in our app through separate files because it makes them easy to change, and easy to create apps that work for multiple different languages and geographical regions.

Furthermore, the actual User Interface (UI) layout of our apps, despite the option to implementthem with a visual designer, are read from text-basedfiles by Android.

Android (or any computer) cannot read and recognize text in the same way that a human can. Therefore, we must present our resources in a highly organized and predefinedmanner. To do so, we will useExtensible Markup Language (XML). XML is a huge topic; fortunately, its whole purpose is to be both human- and machine- readable. We do not need to learn this language; we just need to note (and then conform to) a few rules. Furthermore, most of the time, when we interact with XML, we will do so through a neat visual editor provided by Android Studio. We can tell when we are dealing with an XML resource because the filename will end with the.xml extension.

You do not need to memorize this, as we will constantly be returning to this concept in the book.

Wheneverwe create a new Android app, we will choose a uniquename, known as apackage. We will see how we do this very soon, in the section titledOur first Android app. Packages are often separated intosub-packages so thatthey can be grouped together with other similar packages. We can simply think of these as folders and sub-folders, which is almost exactly what they are.

We can think of all the packages that the Android API makes available to us as code from a code library. Some common Android packages that we will use include the following:

As youcan see, they are arranged and named to make what is in them as obvious as possible.

Earlier, we learnedthat the reusable code blueprints that we can transform into objects are calledclasses. Classes are contained in these packages. We will seein our very first app how we can easilyimport other people's packages, along with specific classes from those packages for use in our projects. A class will usually be contained in its own file with the same name as the class.

In Kotlin,we further break up our classes into sections that perform the different actions of our class. We call these action-oriented sectionsfunctions. It is the functions of the class that we will use to access the functionality providedwithin all the millions of lines of Android code.

We do not need to read the code. We just need to know which class has what we need, which package it is in, and which function from within the class gives us precisely the result we are after.

We can think of the structure of the code we will write ourselves in the same way, although we will usually have just one package per app.

Of course, because of the object-oriented nature of Kotlin, we will only be using selectedparts from this API. Note also that each class has itsown distinctdata. Typically, if you want access to the data in a class, you need to have an object of that class.

By theend of this chapter, we will have imported multiple packages, as well as some classes from them. By the end ofChapter 2,Kotlin, XML, and the UI Designer, we will have even written our very own functions.

1. Run Android Studio in the same way you run any other app. On Windows 10, for example, the launch icon appears in the start menu.

   Tip

   If you are prompted toImport Studio settings from…:, chooseDo not import settings.

2. You willbe greeted with the Android Studio welcome screen, as shown in the following screenshot. Locate theStart a new Android Studio project option and left-click it:
   
3. After this, Android Studio will bring up theChoose your project window, as follows:
   
4. We will use theBasic Activity option, as selected in the previous screenshot. Android Studio will autogenerate some code and a selection of resources to get our project started. We will discuss the code and the resourcesin detail in the next chapter. SelectBasic Activity and clickNext.
5. This next screen is theConfigure your project screen, where we will perform the following steps and a few more things as well:
   1. Name the new project
   2. Provide a company domain as a package name to distinguish our project from any others, in case we should ever decide to publish it on the Play Store
   3. Choose where on our computer the project files should go
   4. Select our preferred programming language
6. The name of our project is going to beHello World, and the location for the files will be yourAndroidProjects folder that we created in theSetting up Android Studio section.
7. The packagename can be almost anything you like. If you have a website, you could use thecom.yourdomain.helloworld format. If not, feel free to usecom.gamecodeschool.helloworld, or something that you just make up. It is only important when you come to publish it.
8. To be clear, in case you can't see the details in the following screenshot clearly, here are the values I used. Remember that yours might vary depending upon your choice of company domain and project save location:

   Option	Value entered
   Name:	Hello World
   Package Name:	com.gamecodeschool.helloworld
   Language:	Kotlin
   Save location:	D:\AndroidProjects\HelloWorld
   Minimum API Level:	Leave at whatever the default is
   This project will support instant apps:	Leave at whatever the default is
   Use AndroidX artifacts:	Select this option

   Note

   Note that the application name has a space between "Hello" and "World," but the project location does not, and will not work if it does.

   Regarding theMinimum API level setting, we already know that the Android SDK is the collection of packages of code that we will be using to develop our apps. Like any good SDK, the Android SDK is regularly updated, and each time it gets a significant update, the version number is increased. Simply put, the higher the version number, the newer the features you get to use; the lower the version number, the more devices our app will work on. For now, the defaultAPI 15, Android 4.0.3 (IceCreamSandwich) version will give us lots of great features and near 100% compatibility with the Android devices currently in use. If, at the time of reading, Android Studio is suggesting a newer API, then go with that.

   If you are reading this some years in the future, then theMinimum API option will probably default to something different, but the code in this book will still work.

   The followingscreenshot shows theConfigure your project screen once you have entered all the information:

   

   Note

   You can write Android apps in a few different languages, including C++ and Java. There are various advantages and disadvantages to each compared to using Kotlin. Learning Kotlin will be a great introduction to other languages, and Kotlin is also the newest (and arguably best) official language of Android.

9. Click theFinish button and Android Studio will prepare our new project for us. Thismight take a few seconds or a few minutes, depending upon how powerful your PC is.

   At this stage, you might be ready to proceed but, depending on the install process, you might need to click a couple of extra buttons.

   Tip

   This is why I mentioned that we are onlyprobably finished installing and setting up.

   Look in the bottom window of Android Studio and see if you have the following message:

   Note

   Note that if you do not see a horizontal window at the bottom of Android Studio like the one shown in the following screenshot, you can skip these two extra steps.

If you do, clickInstall missing platform(s) and sync project, accept the license agreement, andthen clickNext, followed byFinish.

You mayget another message like this:

If thepreceding message appears, clickInstall Build tools…. and then clickFinish.

• Run the app on the emulator on your PC (part of Android Studio) in debug mode
• Run the app on a real Android device in USB debugging mode
• Export the app as a full Android project that can be uploaded to the Play Store

Followthese simple steps to run the appon the default Android emulator:

You'redone. Here is what the app looks likeso far in the emulator. Remember that you might (probably do) have a different emulator, which is fine:

Clearly, wehave more work to do beforewe move to Silicon Valley and look for financial backing, but it is a good start.

We need to test and debug our apps often throughout development to check for any errors, crashes, or anything else unintended.

It is also important to make sure it looks good and runs correctly on every device type/size that you want to target. Obviously, we do not own one of each of the many thousands of Android devices. This is where emulators come in.

Emulators, however, are sometimes a bit slow and cumbersome, although they have improved a lot recently. If we want to get a genuine feel for the experience our user will get, then you can't beat deploying to a real device. So, we will want to use both real devices and emulators while developing our apps.

If you want to try out your app on a tablet, you're going to need a different emulator.

Now we can look at how we can get our app onto a real device.

The firstthing to do is to visit your device manufacturer's website and obtain and install any drivers that are needed for your device and operating system.

The next few steps will set up the Android device for debugging. Note that different manufacturers structure the menu options slightly differently to others. But the following sequence is probably very close, if not exact, for enabling debugging on most devices:

We arenow ready to learn some Kotlin and add our own Kotlin code to the Hello World project.