![images.png](https://cdn.steemitimages.com/DQmYqni9vxME8D1tzy4wZGgu8CT8zK2Goq5cwDaQia7Zg7J/images.png)
[image source](https://goo.gl/images/HbqzGY)
**Repository**: [Python, Open Source Repository](https://github.com/python)

**Software**: For software download python 3.0 compatible with your OS [here](https://www.python.org/downloads/)

**Difficulty** : Intermediate
**What you will learn**:
In this tutorial you will learn how to
-  This an alternative beginners guide to using the ``kivy`` module and its functions.
 
- How to begin Andriod app development with kivy.

- How fix common problems faced with using kivy.

**For my previous posts in the python tutorial series**
-[Click Here* Creating a simple calculator using python 3.8(cpython)](https://steemit.com/utopian-io/@yalzeee/tutorial-developing-a-simple-calculator-with-basic-command-with-python-fix-bugs-in-your-code)

**Creating an encryption key(Cryptography)**
-[ Part 1](https://steemit.com/utopian-io/@yalzeee/tutorial-creating-a-visual-cube-encryption-key-using-python-3-0-part-1)
-[ Part 2](https://steemit.com/utopian-io/@yalzeee/tutorial-creating-a-visual-encryption-key-in-python-3-6-part-2)
-[ Part 3](https://steemit.com/utopian-io/@yalzeee/tutorial-creating-an-visual-cube-encryption-program-with-python-3-6-part-3)
-[ Part 4](https://steemit.com/utopian-io/@yalzeee/tutorial-creating-an-encryption-program-with-python-3-6-part-4)

**Developing an institutions data collection backend and frontend with python 3.6 series**
[Part 1 of this series](https://steemit.com/utopian-io/@yalzeee/tutorial-development-of-an-institutions-data-collection-backend-using-python-3-6-part-1)
[Part 2 of this series](https://steemit.com/utopian-io/@yalzeee/tutorial-development-of-an-institutions-data-collection-back-end-using-python-3-6-part-2)
[Part 3 of this series](https://steemit.com/utopian-io/@yalzeee/tutorial-development-of-an-institutions-data-collection-back-end-with-python-3-part-3)
[Part 4 of this series](https://steemit.com/utopian-io/@yalzeee/tutorial-developing-an-institutions-data-collection-web-front-end-with-python-3-6-part-4)
[Part 5 of this series](https://steemit.com/utopian-io/@yalzeee/tutorial-developing-an-institutions-data-collection-web-front-end-with-python-3-6-part-5)
[Part 6 of this series](https://steemit.com/utopian-io/@yalzeee/tutorial-developing-and-institutions-data-collection-web-front-end-and-back-end-with-python3-6-final-part6)

**Previous Series**
[Automating OnScreen Processes](https://steemit.com/utopian-io/@yalzeee/tutorial-navigation-and-system-interaction-automating-system-processes-in-python-development)
[Screen Mapping and Navigation](https://steemit.com/utopian-io/@yalzeee/tutorial-image-recognition-and-screen-mapping-in-python-developments-part-2)
[Packaging and Deploying](https://steemit.com/utopian-io/@yalzeee/tutorial-packaging-and-deploying-part-3)

**Tutorial**
For a beginner that hopes to start up with kivy, this tutorial would elucidate on a lot of aspects of kivy which most feel are not simplified enough for beginners. To explain the process, I would be building a Simple Tetris App from scratch and deploying it on an android platform. This tutorial would make things easier by separating development into distinguishable and comprehensive steps. Kivy is very favourable for python developers since it enables us run our programs on Andriod, ios and basically any cpu driven device. Note that kivy is specially made for Touch Screen Devices. This should get clearer within the series.

**Kivy**
For information on official documentation and Installation guides [Click Here](https://kivy.org/docs/gettingstarted/intro.html). 

**Starting Up**
As stated earlier we would be building a Simple Tetris App to help understand how kivy works. 
**Note**: I would be seperating steps for better understanding as the ``kivy`` module is quite complex and takes sometime to take in.

**Importing Modules**
Before you get started in kivy, it is advisable to import all neccesary modules at once at the beginning of your project. This is a listing of all the functions we will be needing and the reasons we will be needing this modules.
The first Module we would be importing is the ``kivy`` module.
```
 from kivy import *
#The use of this function in this code is to state the required version for kivy for this program to work
kivy.require('1.9.0')
from kivy.app import App
#This is the kivy function that lets us run our app on andriod, ios and other consoles. It is the backbone of your program
from kivy.uix.widget import Widget
#Widgets are vital for creating structures and giving commands to these structures in kivy. They come with default canvases for drawing.
from kivy.uix.label import Label
# Labels just as their name means are for adding text labels to your program.
from kivy.uix.boxlayout import BoxLayout
# Box Layouts are a set of functions that help us determine the structure of our program.

from kivy.config import Config
# This module is very important for window errors encountered during kivy startups. Without editing this module
It is common to get errors telling you to upgrade your graphic card. Using these lines of code should prevent that if it comes up
Config.set('Config','Multisample', '0')

from random import randint
kivy.clock import Clock
#This module is important in animating our widgets
```

**Creating Our Widgets and Layouts**
Apart from developing the logic for applications kivy is a package that helps us create our Logic beside our Gui.
**Note**: Although this module helps us do this. It is not advisable to put Gui and logic in the same file as it can mix things up alot during development and so kivy gives us a method to seperate our styling from our logic by saving the styling in a similar manner as css in the same folder as your logic file.
To explain this i would show you two instances of the same file but with different formats
``main.py``
```
#Method 1
class HelloWorldApp(App)
    def build():
        return Label(text='helloworld')

if __name__=='__main__':
    HelloWorldApp().Run()
```
``main.py``
```
#Method 2
class HelloWorldApp(App)
    def build():
        return Label
```
``helloWorld.kv``
```
<Label>:
   text: 'HelloWorld'
```
This two pieces of code will yield the same result but it is observable that in ``method1``, the code is all within the ``main.py`` file while in ``method 2``, the styling is within the ``helloworld.kv`` file while the logic is in the ``main.py`` file.
**Note**: The name of the ``.kv`` file must be equal to the name of the app within the ``main.py`` file and located in the same folder to enable the program to find it. 
So using ``Method 2`` Lets begin writing our game.
```
#First thing we Define a widget for the game
class TetrisGame(Widget):
    #Importing from the parent Widget
    pass

#Then we Define our Board or main game area
class Board(Layout):
    pass

#Then we define the main app which is the build point for program
#Fancy way of saying this is where our program runs from
class TetrisApp(App)
   def build(self):
        return TetrisGame()

if __name__=='__main__':
    TetrisApp.run()
#And standard python synthax for running our new code
```
So if you did everything right you should see a blank screen like the one below pop up.
![Screenshot (22).png](https://cdn.steemitimages.com/DQmZL1MnY9HLVWs7Deh2UQdB7TGbqB8zLkXhXm8oHQ8u7CH/Screenshot%20(22).png)
This tutorial continues in the next of its series.

You can find the [Code for this tutorial](https://github.com/yalzeee/Python-tutorial-series/blob/master/Kivy%20Tetris%20App) in Github