Course Overview
This eLearning bundle consists of these 8 courses:
- Java Programming Basics
- Java SE 9
- Android Application Architecture
- Applied Kotlin for Android Application Development
- Hands-on Background Services in Android
- Learn Kotlin Programming
- Learning React Native Development
- Modernizing Your Android Applications
Java Programming Basics – 4:32 hours
Java Programming Basics teaches core Java fundamentals quickly and easily so you can get started programming today. In this course, expert programmer and trainer Simon Roberts introduces the concepts and techniques of Java, as well as the basics of object orientation. You’ll learn the fundamental syntax and how to work with objects, variables, loops, and libraries. You will then practice your skills by creating a chat program from the ground up. This course is step one on your road to becoming a skilled Java developer, with all the exciting possibilities that offers. Major sections are as follows: Lesson 1: Learning Java Lesson 2: Procedural Java Lesson 3: From Structures to Objects Lesson 4: More About Objects Lesson 5: Java IO Libraries and Exceptions Lesson 6: Creating a User Interface Lesson 7: Creating a Chat Program About the Instructor: Simon Roberts started his computing career as a programmer in the early 1980s and built several of his own microprocessor-based computers. He moved to Sun Microsystems, Inc. in mid-1995 and almost immediately became the leading Java instructor in the U.K. In 1998, Simon moved to Colorado, where he still lives. While at Sun, he created the Sun Certified Programmer, Developer, and Architect certifications, and worked in teams on several other certifications. He has written three books on Java, including two certification study guides: one covering the Programmer and Developer exams, and one covering the Architect exam. He left Sun in 2004 and became an independent instructor, architect, and software engineer.
Introduction
Learning Java
Procedural Java
From Structures to Objects
More About Objects
Java IO Libraries and Exceptions
Creating a User Interface
Creating a Chat Program
Java SE 9 – 30:30 hours
Welcome to the Java 9 Master course. whether you’ve programmed before or never had programming experience, by the end of this series you’ll be able to write sophisticated real world java applications. This course will cover installing Java, Eclipse, Intellij and then give an introduction to their uses. Next we’ll talk about java, how to use the IDE and explain basic operators and loops. After that we’ll get you going on classes and objects. it covers inheritance, constructors, overloading and exceptions. Next we’ll cover class design and functionality, polymorphism and then finishes with arrays, arraylists and hashmaps. Autoboxing, enumerations and how to use generics in your code will be covered next, followed by explaining how interfaces allow a bridge to handle inheritance as well as Input/Output and TreeSets. Next we’ll cover how to start using the graphical user interface in java. it covers Swing and proceeds to use Swing to make a flashcard Application to show all the features.
This course will introduce you to JavaFX. It will also cover controls as well as effects and transforming your controls to give your application more life. It will finish with the JavaFX Application lifecycle and how to use SceneBuilder. Then we’ll cover how to create an application login as well as the Details UI in the application, as well as Lambda Expression syntax and how it makes writing your code easier. it also covers an introduction to CRUD operations in Databases as well as an introduction to how threads work in Java. Then we’ll cover your Project Setup and how to structure your database as well as Setting up user login and the Database handlers. We’ll then move on to errorfields and animation as well as FXML views and tasks. It finishes with how to save tasks and customize list view and cells, how to customize list rows, and the tasks by listview, how the application deletes, updates and wraps up, and a refresher on World Wide Web technologies. It then introduces the Vaadin environment as well as how to use Springboot. It starts an application for a weather application also covering how to integrate libraries like OKHTTP as well as how to parse JSON. This course finishes out the weather application fleshing out the User Interface as well as how to update it and make it into a final finished application.
Java SE 9, Part 1 of 14: Install and Introduction
Java SE 9, Part 10 of 14: Project Setup and Login
Java SE 9, Part 11 of 14: Errors and Listview
Java SE 9, Part 12 of 14: Custom Lists and Updates
Java SE 9, Part 13 of 14: Vaadin and HTTP Introduction
Java SE 9, Part 14 of 14: Weather Application
Java SE 9, Part 2 of 14: IntelliJ and Operators
Java SE 9, Part 3 of 14: classes and Objects
Java SE 9, Part 4 of 14: Composition and Arrays
Java SE 9, Part 5 of 14: Interfaces and Streams
Java SE 9, Part 6 of 14: Swing and Flashcard Application
Java SE 9, Part 7 of 14: Intro to Java FX
Java SE 9, Part 8 of 14: Application Login
Java SE 9, Part 9 of 14: Expressions, DB and Threads
Android Application Architecture – 3:55 hours
Android OS has the largest installation base of any operating system in the world. In this course we will learn the skills it takes to build robust, maintainable Android applications. We will focus on architecture and design concepts that make decision making easy, allowing us to focus on developing features while not getting bogged down in broken code or too much up-front planning. We’ll learn that, with the right understanding and preparation, the process of Android application development can be as rewarding as using and sharing the applications we develop. This course provides the foundational constructs, processes, and tools that are needed to write stable, full–featured, and maintainable Android applications. We cover architectural concepts for the UI layer, which is often the easiest part of the application to lose control of, and explore the overall application architecture. You will start by building a UI for a personal project management application, organized into an MVP architecture. You will then leverage Google’s LiveData and ViewModel to handle Activity lifecycle concerns while also implementing RxJava to make the UI layer completely reactive. Next, you will explore Bob Martin’s Clean Architecture and learn how to begin thinking about the application in terms of layers of functionality: from the business domain, through use cases, and finally to the strap-on user interface. Lastly, you will integrate your app with a RESTful API to back up your data in the cloud.
UI ARCHITECTURE
The Course Overview
MVC Architecture
MVVM
MVP
Testing at the UI Layer
CREATING AN APPLICATION UI
Creating a VisualList of Projects
Extracting a Model from Our UI Needs
Android Architectural Components – ViewModel and LiveData
Inversion of Control and Dependency Injection
Moving the View-Controlling Logic into a Presenter
Testing Our Presenter
REACTIVE DESIGN
Inflows, Outflows, and Marbles
Single,Maybe, Completable, Observable
Mutations – Map and Flat Map
Intersections
Subjects
Error Handling
APPLYING REACTIVE DESIGN TO OUR APPLICATION
Making Our Project List Reactive
Making Our Project List ViewModel and LiveData Reactive
Making Our Presenter Reactive
RxJava Testing
IMPLEMENTING A CLEAN ARCHITECTURE
Thinking in Clean Architecture
Business Model, Interactors, and Presentation Layer
Building Our Business Layer
Building Out Our CRUD with Google’s Room Library
Creating Interactors for Our Projects List and Testing Them
INTEGRATING WITH A THIRD-PARTY API
REST API Design
Creating a Simple REST API
Parsing Our REST API with Retrofit
Applied Kotlin for Android Application Development – 2:23 hours
Kotlin greatly reduces source code verbosity. With Google having announced its support for Kotlin as a first-class language for writing Android apps, now’s the time to learn how to create apps from scratch with Kotlin The Applied Kotlin for Android Application Development course is for developers who have some experience in the basics of Kotlin and are ready to take the plunge into the more advanced stage. This course covers Kotlin’s superpowers, as it were. You should already know the syntax, but now we will go over the things that make Kotlin stand out—such as inline functions and null safety.You will learn about Anko, a Kotlin library which makes Android application development faster and easier. It makes your code clean and easy to read and smoothes out the rough edges in the Android SDK for Java. You will also publish the app you built during the course to get an overall end-to-end experience of Kotlin Android application development. By the end of this course, you will have gained experience in creating and deploying Android applications using Kotlin.
NEXT-GEN FUNCTIONS
The Course Overview
Lambdas
Higher Order Functions
Extension Functions
Inline Functions
INTERFACES
Implementing Interfaces
Properties in Interfaces
Resolving Overriding Conflicts
SALIENT FEATURES IN KOTLIN
Operator Overload
Delegation
Property Delegation
Null Safety
Sealed Classes
Enum Classes
EXPLORING ANKO AND PUBLISHING THE APP TO GOOGLE PLAY
What Is Anko?
Simple Intents, Finally!
Dialogs and Toasts
Logging
Background Threads
Preparing for Google Play
Hands-on Background Services in Android – 3:02 hours
This course helps developers who want to build applications working in the background, by exposing you to using Android Background Service capabilities effectively. Services come out as the best option with backward app compatibility. You will learn a variety of topics like starting and stopping your service, interacting with the background service and creating and sending a work request, exploring the lifecycle of your service along with understanding the security issues in using it. You will learn to use IntentService, which utilizes a worker or background thread to execute tasks. You will explore what’s new in the Background Service in Android Oreo and check out its limitations, and then overcome those limitations. You will then learn best practices and how to deal with problems and issues that might arise By the end of the course, you will have a strong foundation in background services in Android and will be able to build the function you need to ensure you won’t drain the battery excessively, compromise the user’s security, consume too much data, or hamper the device’s performance.
EXPLORING BACKGROUND SERVICE IN PRACTICAL APPS
The Course Overview
Exploring Android Components
Exploring Activity, Broadcast Receiver, and Content Provider
Introduction to Service
Types of Service
Foreground Versus Background Service
Understanding Threads and Processes
Different Ways to Perform Background Operations
CREATING A BACKGROUND SERVICE
Project Setup
Implementing Background Service
Start and Stop a Background Service
Return Flags for Background Service
Background Service Runs in Main Thread
Using AsyncTask with Background Service
WORKING WITH INTENTSERVICE THAT USES WORKER THREAD
Why IntentService?
Performing Operations Using IntentService in a Worker Thread
Started Service Versus IntentService
INTERACTING WITH BACKGROUND SERVICE
Create and Send a Work Request to an IntentService
Use Local Broadcasts to Interact with Background Service
Reporting Work Status to the Calling Component
EXPLORING THE LIFECYCLE OF A SERVICE
Exploring Lifecycle of Started Service
Importance of Lifecycle Methods
Enhancing Application Security Using Started Service
BACKGROUND SERVICE LIMITATIONS AND WORK AROUND
What’s New for Background Execution in Android Oreo
Background Service Limitation
Work Around – JobIntentService
Demo – JobIntentService
TROUBLESHOOTING BACKGROUND SERVICE
Best Practices for Implementing Background Service in Apps
In Conclusion the Next Steps
Learn Kotlin Programming – 4:28 hours
Kotlin is a statically typed language whose syntax is more expressive and concise. Kotlin has been adopted by Google as a first-class language for developing Android apps. Since then, Kotlin has gained a huge popularity worldwide among developers due to its highly appreciable features, which we will cover in this course. The course starts by showing you how to set up the Kotlin environment and install Intellij IDEA to write Kotlin code. After that, the course dives into the Kotlin basics and fundamentals such as variables, data types, string templates, expressions, null values, and loops. Moving on, you’ll learn how to write functions in Kotlin. You’ll explore Kotlin as an Object-Oriented Language by exploring interfaces and various Kotlin classes . Next you’ll dive into Functional programming in Kotlin using Lambdas and higher-order functions . Finally, you’ll explore the collection framework and perform operations such as filtering and sorting using Predicates and FlatMaps in Kotlin. By the end of the course, you’ll be able to build your own robust program in Kotlin.
GETTING STARTED WITH KOTLIN
The Course Overview
Introduction to Kotlin
Installing Software on Windows
Installing Software on Mac
Installing Software on Linux
Writing Your First Kotlin Program
Exploring Your First App
KOTLIN DATA TYPES, EXPRESSIONS, AND CONDITIONAL STATEMENTS
Exploring Variables and Data Types
Demo – Variables and Data Types
Playing with String Templates
Kotlin Expressions – If
Kotlin Expressions – When
Using Loops in Kotlin
Handling Exceptions
EXPLORING FUNCTIONS IN KOTLIN
Introduction to Kotlin Functions
Declaration of Functions
Exploring the Default Parameters
Using Named Parameters
Avoiding Stack Overflow Exception by Using Tail Recursive Function
PROGRAMMING WITH INTERFACES AND CLASSES IN KOTLIN
Defining a Class in Kotlin
Working with Constructors and init Block
Exploring Inheritance
Exploring Interface
Using Data Classes
STATICS IN KOTLIN – COMPANION OBJECTS
Understanding Kotlin Statics
‘object’ Declaration
Using Companion Object
FUNCTIONAL PROGRAMMING IN KOTLIN
Introduction to Higher-Order Functions and Lambda Expressions
Using Higher Order Function and Lambda
Working with Closures
Implement ‘it’ keyword
Implement ‘with’ and ‘apply’ Keywords
FILTERING AND SORTING – HANDLING LARGE DATA
Introduction to Arrays
Exploring Lists – Mutable and Immutable
Filtering Data
Modifying Data
Exploring Set
Exploring Map
LEVERAGING THE POWER OF KOTLIN
Handling Null Values
Exploring Extension Functions
Putting it all together: the Power of Kotlin
Learning React Native Development – 3:10 hours
React Native is a JavaScript framework that lets you rapidly build native apps for both iOS and Android using a single language. A React native app is not a hybrid app so it’s nearly indistinguishable from native apps built with Java and Objective-C.Our course is a fast-paced guide to get you started with React Native and building Native mobile apps. The course will give React developers all they need to build native iOS and Android apps. We won’t be covering the basics of JavaScript programming or React. We will delve directly into React Native to build native mobile apps. You will learn to develop apps that are fun, unique, and responsive with React Native. Learn React Native fundamentals to build interactive and user-friendly apps. The course aims at teaching you React Native irrespective of the underlying platform so that you can learn once, write anywhere.This course adopts a practical approach to get you building apps as soon as possible. With this course, you will get minimal theory and maximal action, with compelling illustrative examples and clear explanations.
GETTING STARTED WITH REACT NATIVE
The Course Overview
Installation and Setup
Running the Simulator
Understanding JSX
STYLING WITH REACT COMPONENTS
App Overview
Styling the Header
Structuring the Photo Section
Flexbox
Styling the Photo Section
FETCHING DYNAMIC DATA
Endpoint to Fetch Data
Functional versus Class-Based Components
Axios
React States
Lifecycle Methods
Looping Through Photo Section
Implementing the Like Button
INTRODUCING REDUX
What Is Redux?
Managing State Using Redux
Action Creators
Creating the Photos Reducer
Calling Actions from Components
HANDLING AUTHENTICATION
Login Form Overview
Structuring the Login Form
Firebase Configuration
Managing Input State
Storing Form Input in Reducers
Getting the Form Input Values
Firebase Login API
Login Wrapup
CREATING YOUR OWN APP
App Overview of IdeaPad
Configuring the Database
Structuring the IdeaPad Form
Submitting Ideas
Showing List of Ideas
HANDLING NAVIGATION
React Native Navigation
Navigating Between Screens
Fetching Data from Firebase
Editing Ideas
Editing Action Creator
Deleting Ideas
Modernizing Your Android Applications – 4:29 hours
Programming Android apps can be a complex process and lack of knowledge in architecting your app can result in spaghetti code and dead ends. In order to deliver an extendable, maintainable, and testable code base, you have to think about the architecture of your application from the very first stage of your development. In this course, you’ll take an existing Android application build in Java and modernize it using the Kotlin language, seeing the importance of planning the architecture using SOLID principles and common Android Architecture using the MVP, MVC, and MVVM patterns. Moving on, you’ll implement Life Cycle Aware Components, use the viewmodel LiveData framework, and perform data management and persistence with the Room persistence solution. You’ll see how Kotlin efficiently accelerates the development by improving the code base. With the advanced Architectural Components, you’ll not only be able to improve the performance but also enhance the UI of your application to a whole new level. By the end of this course, you’ll have modernized your Android app using all the new features from coding it in Kotlin to implementing Architecture Components to enhancing the UI of your app, which gives you more control on your app and makes it easy to maintain.
WELCOME TO THE COOL NEW ANDROID
The Course Overview
Layout Design and Management
Rotations and Recreations
New Layouts
New Lists
MEASURE PERFORMANCE WITH CODE PROFILING
Old Code Profiling
New Code Profiling
Memory Leaks
CODDLING KOTLIN
Converting Java to Kotlin
Extension Functions
Operator Overload
Kotlin Android Extensions
KTX
DATA STORAGE AND MANAGEMENT WITH ROOM DB
Data Persistence the Old Way
Data Persistence the New Way
Inserting Data and Writing Queries
Updating and Deleting Data
LIFECYCLE, VIEWMODEL, AND LIVEDATA
Dynamic Data Loading
Handling Lifecycles Callbacks
Responding to State Changes
New Way to Respond to State Changes
Using ViewModel to Restore and Manage Data
Implementing LiveData
IMPLEMENTING DATA BINDING AND PAGING LIBRARIES
Exploring Data Binding
Adding Layouts and Binding Expressions
Bind Layout Views to Architecture Components
Implementing Paging Library
UI Components and Considerations
Data Components and Considerations
SCHEDULING TASKS USING WORKMANAGER API
Implementing WorkManager to Schedule Tasks
Running Tasks Under Specific Conditions
Setting Up Unique and Named Work Sequences
