This document provides instructions for setting up an environment for Android development. It discusses downloading and installing the Java Development Kit (JDK), Android SDK, and Android Studio. It also covers configuring a real Android device or emulator for testing apps. The document demonstrates creating a basic "Hello World" Android app in Android Studio and reviewing the underlying code and manifest file. It then briefly describes a more advanced app that scans for nearby WiFi access points when a button is pressed.
This document provides an overview of getting started with Android development. It discusses downloading the necessary software, creating an Android project and basic activity, and understanding key Android building blocks like activities, intents, views, and layouts. It also demonstrates a simple "Hello World" Android app.
Android - From Zero to Hero @ DEVit 2017Ivo Neskovic
The workshop deals with the design and implementation of applications for mobile devices using the Android operating system. Participants work at all stages of the development life-cycle from inception to deployment, whilst considering usability and device capabilities for a mobile application capable of meeting a functional specification. Participants are introduced to the programming environment for application development and have a hands-on approach to programming using the appropriate programming languages.
Android Development for Beginners with Sample Project - Day 1Joemarie Amparo
Android Development Training for Beginners covers an overview of Android, installing the Android Development Tools (ADT) plugin for Eclipse, exploring project components, creating a sample Android project, and running the project. The document outlines the first day module which introduces Android, explains that it is an open source mobile platform developed by Google and the Open Handset Alliance, and defines the software stack. It also provides a brief history of Android and versions released. The document discusses project structure, layouts, strings, the manifest file, and includes code examples for creating an activity and handling button clicks.
The document outlines a series of Android labs covering topics such as linear layout, relative layout, table layout, list view layout, menus, dialogs, widgets, shared preferences, SQLite, intents, content providers, and broadcast receivers. It also provides references to additional Android resources for further learning. The labs are designed to teach Android fundamentals and cover creating basic UI layouts using different layout types, adding interactivity with menus and dialogs, storing and retrieving data, and implementing core Android application concepts.
Fragments represent reusable portions of user interface in an activity. An activity can host multiple fragments that the user can navigate between. Fragment transactions allow adding, replacing, and removing fragments within an activity. Fragments can communicate with each other using interfaces to pass data between fragments hosted by the same activity.
[/SUMMARY]
Getting started with android dev and test perspectiveGunjan Kumar
The presentation covers basic intro to Android, how to get started with development, including instructions on setup, common UI usages like menus, dialogs; details on services like Sensors, Location and Google Maps
It also covers ideas on how to test including details on shell and installation instructions without using Eclipse
Android is an open source operating system used for mobile devices like smartphones and tablets. It is developed by Google and managed by the Open Handset Alliance. The Android manifest file contains important configuration settings for Android applications, including supported SDK versions, required permissions, application components and more. It determines how the application interacts with the operating system.
The document discusses the basic components of an Android app. It explains that an Android app consists of components like activities, services, broadcast receivers, and content providers. Activities provide the main user interface and common ones include launching the app and navigating within it. The app manifest file defines these components. The document also covers activities and intents, explaining how activities are launched via explicit and implicit intents and how data can be passed between activities.
This document provides an overview of getting started with Android development. It discusses downloading the necessary software, creating an Android project and basic activity, and understanding key Android building blocks like activities, intents, views, and layouts. It also demonstrates a simple "Hello World" Android app.
Android - From Zero to Hero @ DEVit 2017Ivo Neskovic
The workshop deals with the design and implementation of applications for mobile devices using the Android operating system. Participants work at all stages of the development life-cycle from inception to deployment, whilst considering usability and device capabilities for a mobile application capable of meeting a functional specification. Participants are introduced to the programming environment for application development and have a hands-on approach to programming using the appropriate programming languages.
Android Development for Beginners with Sample Project - Day 1Joemarie Amparo
Android Development Training for Beginners covers an overview of Android, installing the Android Development Tools (ADT) plugin for Eclipse, exploring project components, creating a sample Android project, and running the project. The document outlines the first day module which introduces Android, explains that it is an open source mobile platform developed by Google and the Open Handset Alliance, and defines the software stack. It also provides a brief history of Android and versions released. The document discusses project structure, layouts, strings, the manifest file, and includes code examples for creating an activity and handling button clicks.
The document outlines a series of Android labs covering topics such as linear layout, relative layout, table layout, list view layout, menus, dialogs, widgets, shared preferences, SQLite, intents, content providers, and broadcast receivers. It also provides references to additional Android resources for further learning. The labs are designed to teach Android fundamentals and cover creating basic UI layouts using different layout types, adding interactivity with menus and dialogs, storing and retrieving data, and implementing core Android application concepts.
Fragments represent reusable portions of user interface in an activity. An activity can host multiple fragments that the user can navigate between. Fragment transactions allow adding, replacing, and removing fragments within an activity. Fragments can communicate with each other using interfaces to pass data between fragments hosted by the same activity.
[/SUMMARY]
Getting started with android dev and test perspectiveGunjan Kumar
The presentation covers basic intro to Android, how to get started with development, including instructions on setup, common UI usages like menus, dialogs; details on services like Sensors, Location and Google Maps
It also covers ideas on how to test including details on shell and installation instructions without using Eclipse
Android is an open source operating system used for mobile devices like smartphones and tablets. It is developed by Google and managed by the Open Handset Alliance. The Android manifest file contains important configuration settings for Android applications, including supported SDK versions, required permissions, application components and more. It determines how the application interacts with the operating system.
The document discusses the basic components of an Android app. It explains that an Android app consists of components like activities, services, broadcast receivers, and content providers. Activities provide the main user interface and common ones include launching the app and navigating within it. The app manifest file defines these components. The document also covers activities and intents, explaining how activities are launched via explicit and implicit intents and how data can be passed between activities.
An Android application is composed of activities, services, and content providers. Activities display user interfaces and are launched by intents. The context provides access to application-wide resources and functionality. Activities have a lifecycle of states like resumed, paused, and stopped that are called back through methods to manage resources. Intents are used to transition between activities within an app or launch other apps' components.
This document provides an overview of Android basics including UI elements, views, view groups, common layouts, buttons, text views, lists views, grid views, and fragments. It discusses the view hierarchy and how views and view groups are arranged in a tree structure. It provides examples of linear, relative, grid and list layouts and how to define buttons, text fields, labels and other widgets. It also covers topics like event handling, populating spinners and pickers, and using fragments in an Android application.
The document provides an overview of an Android architecture presentation. It discusses key topics like the Android virtual machine, application stack and framework, core libraries, and the main components of an Android application. For application components, it covers the AndroidManifest file, activities and their lifecycle, intents, application resources including strings and drawables, and localization. It provides examples and code snippets for many of these topics. It also lists additional topics that will be covered in part two of the presentation, such as preferences, app widgets, services, and content providers.
Android Development: Build Android App from ScratchTaufan Erfiyanto
a month ago, i have a change to held a one day workshop about Android development at Phetchaburi Rajabhat University, Thailand. The workshop is attended by students and lecturers. it is a pleasure to me to see many people that excited to learn android development.
This is a presentation slide of my presentation. in this presentation you will learn about how to build create a simple to do list app from scratch.
content of the presentation slide:
- Introduction: what Android is?
- Android development tools
- Creating Android Project
- Understanding the Project Structure
- Creating Android Emulator
- Running Android Project on Emulator
- Running Android Project on Device
- Creating User Interface
- Manipulating Widget
- Creating To Do List App
- Integrating SQLite Database to Android Project
A 1 day NTU workshop for kickstarting Android development. Includes using the newest & better IDE - Android Studio - and a thorough process from developing you idea > mockup > coding > polishing > distributing.
Being Epic: Best Practices for Android DevelopmentReto Meier
This document provides best practices for Android development. It discusses five "deadly sins" to avoid: sloth (being slow and unresponsive), gluttony (using system resources irresponsibly), hostility (fighting users), arrogance (fighting the system), and discrimination. It also discusses five "glorious virtues" to embrace: beauty (design), generosity (sharing), ubiquity (being everywhere), utility (being useful), and epicness (being legendary). It covers topics like performance, wake locks, navigation, preferences, undocumented APIs, screen sizes, analytics, background updates, location services, and more. The overall message is to create high-quality, useful apps that respect users and system resources.
This document provides an overview of setting up the Android development environment and creating basic Android projects. It discusses downloading the Java Development Kit (JDK), Eclipse IDE, and Android SDK. It also explains how to install the Android Development Tools (ADT) plugin for Eclipse and configure the SDK and AVD Manager. The document demonstrates how to create a simple "Hello World" project and tabbed application. It also provides information on accessing sensors like GPS and accelerometers as well as using local SQLite and remote databases with Android applications.
The document discusses the basic components of Android applications:
- Activities represent single screens and user interfaces. The first activity launched is the entry point.
- Services run in the background for long-running tasks like playing music.
- Broadcast receivers respond to messages from other apps and the system, like downloading completion.
- Content providers manage shared app data stored in files, databases, and more.
The document discusses the iPhone SDK and its core components. It describes how view controllers work in the SDK, including how they load views from nibs, respond to memory warnings, and handle the view lifecycle through methods like viewDidLoad and viewWillAppear. It also provides an example of initializing and implementing a view controller class.
This document provides an introduction and tutorial on Android concepts and programming. It covers installing the Android SDK and setting up a development environment. It then demonstrates how to create a simple "Hello World" Android app with basic UI elements like buttons, edit texts, and text views. It also introduces some key Android concepts like activities, intents, and the sensor manager API for accessing device sensors. The goal is to help readers quickly get started with Android programming and cover topics not fully explained in the Android documentation.
The new build mechanism replacing Ant for Android development is based on Gradle, the popular build tool from the Groovy ecosystem. Ken Kousen introduces you to Gradle for Android developers and shows how easy it is to integrate Gradle into Android projects. We’ll show the latest version of the Android Studio IDE to develop applications. Join Ken to discuss using the Android plugin for Gradle; adding dependencies and alternate repositories; creating custom tasks; implementing both unit and integration tests; using alternative build types, product flavors, and variants; and more. Leave with an appreciation and understanding of Gradle and how to use it in your development environment.
Raman Pandey's presentation discusses the basics of Android app development, including:
- Android is an open source operating system for mobile devices based on Linux.
- Java programming knowledge and software like Java JDK, Android SDK, and Android Studio are prerequisites.
- The Android architecture includes layers like applications, application framework, libraries and the Linux kernel.
- Application components, resources, intents, fragments, UI layouts and the emulator are discussed as fundamental concepts.
Getting Started with XCTest and XCUITest for iOS App TestingBitbar
Watch a live presentation at http://offer.bitbar.com/getting-started-with-xctest-and-xcuitest-for-ios-app-testing
XCTest has been part of Xcode for few years already, but it is finally catching up and more developers are getting on the bandwagon. XCTest and XCUITest provide feature-rich capabilities for iOS developers and test automation folks to implement different levels of tests using Xcode features and supported programming languages, Objective-C and Swift.
Stay tuned and join our upcoming webinars at http://bitbar.com/testing/webinars/
The document discusses Android activities and fragments. It defines an activity as representing a single screen with a user interface. It notes that an app may have multiple activities for different screens like email lists, compose, and read. It then discusses the activity lifecycle and callbacks like onCreate(), onStart(), onResume(), etc. It provides an example logging the lifecycle. It defines a fragment as a modular piece of UI/behavior that can be placed in an activity. It discusses combining fragments in different configurations for tablets vs phones. It also covers the fragment lifecycle and provides an example creating two fragments for landscape and portrait orientations.
The document discusses Android application development. It provides an overview of the Android platform, including that it is an open source software stack for mobile devices powered by Linux. It describes the installation of development tools like Eclipse and the Android SDK. It then covers the basic building blocks for Android apps like activities, services, intents, and content providers.
This document provides an introduction to using Gradle with Android Studio. It discusses the benefits of Gradle such as its Groovy-based syntax and improved dependency management. It also covers how to convert an existing Android project to use Gradle, adding build types and product flavors to create multiple APK variants, defining custom tasks, and setting up testing and continuous integration with Jenkins.
Exploring the power of Gradle in android studio - Basics & BeyondKaushal Dhruw
In this presentation we will explore the official build system of android studio. Gradle. We will discuss about Gradle basics, Gradle Wrapper and its usage in android studio. We will explore the possibilities with gradle by covering beginner and advanced level topics.
What you can expect:
1. Just enough gradle to get started.
2. Creating simple and custom gradle tasks.
3. Gradle in android studio
4. Exploring product flavors
5. Using product flavors to our advantage.
6. facebook's stetho debug bridge and configuration via flavors.
This document provides an overview of Gradle, an open-source build automation tool. It discusses how Gradle offers flexibility and convention-based dependency management powered by Groovy. The document also covers installing Gradle, build phases, common plugins for languages and software development, and includes examples of using Gradle with Java projects. It concludes by inviting questions.
An Android application is composed of activities, services, and content providers. Activities display user interfaces and are launched by intents. The context provides access to application-wide resources and functionality. Activities have a lifecycle of states like resumed, paused, and stopped that are called back through methods to manage resources. Intents are used to transition between activities within an app or launch other apps' components.
This document provides an overview of Android basics including UI elements, views, view groups, common layouts, buttons, text views, lists views, grid views, and fragments. It discusses the view hierarchy and how views and view groups are arranged in a tree structure. It provides examples of linear, relative, grid and list layouts and how to define buttons, text fields, labels and other widgets. It also covers topics like event handling, populating spinners and pickers, and using fragments in an Android application.
The document provides an overview of an Android architecture presentation. It discusses key topics like the Android virtual machine, application stack and framework, core libraries, and the main components of an Android application. For application components, it covers the AndroidManifest file, activities and their lifecycle, intents, application resources including strings and drawables, and localization. It provides examples and code snippets for many of these topics. It also lists additional topics that will be covered in part two of the presentation, such as preferences, app widgets, services, and content providers.
Android Development: Build Android App from ScratchTaufan Erfiyanto
a month ago, i have a change to held a one day workshop about Android development at Phetchaburi Rajabhat University, Thailand. The workshop is attended by students and lecturers. it is a pleasure to me to see many people that excited to learn android development.
This is a presentation slide of my presentation. in this presentation you will learn about how to build create a simple to do list app from scratch.
content of the presentation slide:
- Introduction: what Android is?
- Android development tools
- Creating Android Project
- Understanding the Project Structure
- Creating Android Emulator
- Running Android Project on Emulator
- Running Android Project on Device
- Creating User Interface
- Manipulating Widget
- Creating To Do List App
- Integrating SQLite Database to Android Project
A 1 day NTU workshop for kickstarting Android development. Includes using the newest & better IDE - Android Studio - and a thorough process from developing you idea > mockup > coding > polishing > distributing.
Being Epic: Best Practices for Android DevelopmentReto Meier
This document provides best practices for Android development. It discusses five "deadly sins" to avoid: sloth (being slow and unresponsive), gluttony (using system resources irresponsibly), hostility (fighting users), arrogance (fighting the system), and discrimination. It also discusses five "glorious virtues" to embrace: beauty (design), generosity (sharing), ubiquity (being everywhere), utility (being useful), and epicness (being legendary). It covers topics like performance, wake locks, navigation, preferences, undocumented APIs, screen sizes, analytics, background updates, location services, and more. The overall message is to create high-quality, useful apps that respect users and system resources.
This document provides an overview of setting up the Android development environment and creating basic Android projects. It discusses downloading the Java Development Kit (JDK), Eclipse IDE, and Android SDK. It also explains how to install the Android Development Tools (ADT) plugin for Eclipse and configure the SDK and AVD Manager. The document demonstrates how to create a simple "Hello World" project and tabbed application. It also provides information on accessing sensors like GPS and accelerometers as well as using local SQLite and remote databases with Android applications.
The document discusses the basic components of Android applications:
- Activities represent single screens and user interfaces. The first activity launched is the entry point.
- Services run in the background for long-running tasks like playing music.
- Broadcast receivers respond to messages from other apps and the system, like downloading completion.
- Content providers manage shared app data stored in files, databases, and more.
The document discusses the iPhone SDK and its core components. It describes how view controllers work in the SDK, including how they load views from nibs, respond to memory warnings, and handle the view lifecycle through methods like viewDidLoad and viewWillAppear. It also provides an example of initializing and implementing a view controller class.
This document provides an introduction and tutorial on Android concepts and programming. It covers installing the Android SDK and setting up a development environment. It then demonstrates how to create a simple "Hello World" Android app with basic UI elements like buttons, edit texts, and text views. It also introduces some key Android concepts like activities, intents, and the sensor manager API for accessing device sensors. The goal is to help readers quickly get started with Android programming and cover topics not fully explained in the Android documentation.
The new build mechanism replacing Ant for Android development is based on Gradle, the popular build tool from the Groovy ecosystem. Ken Kousen introduces you to Gradle for Android developers and shows how easy it is to integrate Gradle into Android projects. We’ll show the latest version of the Android Studio IDE to develop applications. Join Ken to discuss using the Android plugin for Gradle; adding dependencies and alternate repositories; creating custom tasks; implementing both unit and integration tests; using alternative build types, product flavors, and variants; and more. Leave with an appreciation and understanding of Gradle and how to use it in your development environment.
Raman Pandey's presentation discusses the basics of Android app development, including:
- Android is an open source operating system for mobile devices based on Linux.
- Java programming knowledge and software like Java JDK, Android SDK, and Android Studio are prerequisites.
- The Android architecture includes layers like applications, application framework, libraries and the Linux kernel.
- Application components, resources, intents, fragments, UI layouts and the emulator are discussed as fundamental concepts.
Getting Started with XCTest and XCUITest for iOS App TestingBitbar
Watch a live presentation at http://offer.bitbar.com/getting-started-with-xctest-and-xcuitest-for-ios-app-testing
XCTest has been part of Xcode for few years already, but it is finally catching up and more developers are getting on the bandwagon. XCTest and XCUITest provide feature-rich capabilities for iOS developers and test automation folks to implement different levels of tests using Xcode features and supported programming languages, Objective-C and Swift.
Stay tuned and join our upcoming webinars at http://bitbar.com/testing/webinars/
The document discusses Android activities and fragments. It defines an activity as representing a single screen with a user interface. It notes that an app may have multiple activities for different screens like email lists, compose, and read. It then discusses the activity lifecycle and callbacks like onCreate(), onStart(), onResume(), etc. It provides an example logging the lifecycle. It defines a fragment as a modular piece of UI/behavior that can be placed in an activity. It discusses combining fragments in different configurations for tablets vs phones. It also covers the fragment lifecycle and provides an example creating two fragments for landscape and portrait orientations.
The document discusses Android application development. It provides an overview of the Android platform, including that it is an open source software stack for mobile devices powered by Linux. It describes the installation of development tools like Eclipse and the Android SDK. It then covers the basic building blocks for Android apps like activities, services, intents, and content providers.
This document provides an introduction to using Gradle with Android Studio. It discusses the benefits of Gradle such as its Groovy-based syntax and improved dependency management. It also covers how to convert an existing Android project to use Gradle, adding build types and product flavors to create multiple APK variants, defining custom tasks, and setting up testing and continuous integration with Jenkins.
Exploring the power of Gradle in android studio - Basics & BeyondKaushal Dhruw
In this presentation we will explore the official build system of android studio. Gradle. We will discuss about Gradle basics, Gradle Wrapper and its usage in android studio. We will explore the possibilities with gradle by covering beginner and advanced level topics.
What you can expect:
1. Just enough gradle to get started.
2. Creating simple and custom gradle tasks.
3. Gradle in android studio
4. Exploring product flavors
5. Using product flavors to our advantage.
6. facebook's stetho debug bridge and configuration via flavors.
This document provides an overview of Gradle, an open-source build automation tool. It discusses how Gradle offers flexibility and convention-based dependency management powered by Groovy. The document also covers installing Gradle, build phases, common plugins for languages and software development, and includes examples of using Gradle with Java projects. It concludes by inviting questions.
This document provides an introduction and overview of Android application development. It discusses what Android is, how to install the necessary development tools like Eclipse and the Android SDK, and covers Android application fundamentals such as the different application components and the Android manifest file. It also demonstrates how to create a simple "Hello World" Android application in Eclipse by setting up an Android virtual device, creating an Android project, writing the code, and running the app on the emulator.
This document provides an overview of Android development, including:
- What Android is and its key components like the Linux kernel and Dalvik VM.
- The fundamentals of building Android apps using Java and the app framework, including activities, services, content providers, and broadcast receivers.
- How the Android framework API works for each component and their lifecycles.
- How to get started with Android development using the SDK tools, Eclipse plugin, and creating a simple test project and virtual device.
This document provides an overview of Android and how to get started developing Android applications. It discusses what Android is, Google's plans for Android, why developers should use Android, the Android platform including hardware, operating system, and network connectivity. It also covers getting the prerequisites like Java, Eclipse, and the Android SDK installed and configured, creating a "Hello World" Android project, understanding the code structure, and an overview of the Android manifest file and XML layouts.
The document discusses the history and evolution of smartphones from early devices like the Motorola DynaTAC 8000x to modern smartphones. It covers key aspects of smartphones like operating systems (Android, iOS, etc.), mobile development platforms, and the architecture and components of the Android operating system. It provides instructions on setting up development environments and outlines the basic process for creating a simple "Hello World" Android app, including key files like the manifest, layout files, and Java source code. Finally, it discusses a more complex example app for scanning and displaying nearby WiFi access points.
This document discusses native Android development practices and provides an overview of using Spring for mobile web applications and Android development. It covers Spring Mobile features like device detection and site preference management. It then introduces basic Android development concepts like activities, services, and manifest registration. It demonstrates a simple "Hello World" Android activity and discusses Android lifecycles. Finally, it discusses using Maven for Android projects.
The document discusses the Android platform. It describes Android as a layered environment built upon the Linux kernel that includes rich functions. It notes that Android includes an embeddable browser built on WebKit and supports connectivity options like WiFi, Bluetooth and wireless data. It also includes support for graphics, media, 2D/3D graphics via OpenGL, and data storage via SQLite. The software layers include applications, application framework, libraries and services, and the Linux kernel.
This document provides an overview of teaching Android application development. It discusses what Android is, why it is useful to teach, and what is needed to get started. Key topics covered include using Java to build Android apps, utilizing the Android software development kit and Eclipse IDE, and creating a simple "Hello World" app as a first project. Resources like the Android developer website and emulator are also introduced.
If you want to start a good career in Android Development, this presentation gives you a basic introduction about Android, and how you can develop your very first Android Application.
Android is a software stack that includes an operating system and applications for mobile devices. It is based on the Linux kernel and was developed by the Open Handset Alliance, including Google. Android supports a variety of hardware platforms and provides features like storage, messaging, a web browser, media support, Bluetooth, and more. Developers can create Android applications using the Android SDK and Eclipse IDE, targeting the Dalvik virtual machine. The SDK includes tools, libraries, and sample code needed to build Android apps.
Android is a software stack that includes an operating system and applications for mobile devices. It is based on the Linux kernel and was developed by the Open Handset Alliance, including Google. Android supports a variety of hardware platforms and provides features like storage, messaging, a web browser, media support, Bluetooth, and more. Developers can create Android applications using the Android SDK and Eclipse IDE, targeting the Dalvik virtual machine. The SDK includes tools, libraries, and sample code needed to build Android apps.
The document provides an overview of Google Android, including that it is an open source software stack for mobile devices consisting of an operating system, middleware, and key applications. It describes Android application development using the Java programming language, the Dalvik virtual machine, and Android SDK tools like Eclipse. It also summarizes some important Android application programming interfaces and concepts like activities, intents, and the Android manifest file.
The document provides an overview of Google Android, including that it is an open source software stack for mobile devices consisting of an operating system, middleware, and key applications. It describes Android application development using the Java programming language, the Dalvik virtual machine, and Android SDK tools like Eclipse. It also summarizes some important Android application programming interfaces and concepts like activities, intents, and the Android manifest file.
The slides from the Java Meetup which was held in 12th of March 2015 at WSO2 Inc. Sri Lanka. Introduction to Android Development. By : Kasun Delgolla, Chathura Dilan And Inosh Perera, Engineers @ WSO2.
This document provides an overview of Android, including:
- Android is an open source software stack that includes an operating system, middleware, and key applications developed by the Open Handset Alliance led by Google.
- The history of Android began in 2007 with the founding of the Open Handset Alliance and the unveiling of the Android platform.
- The document then describes the core components that make up the Android software stack including the Linux kernel, Dalvik runtime, core libraries, framework, and applications.
- It also provides basic steps for developing Android applications including setup, development, debugging and testing, and publishing.
Android interview questions and answerskavinilavuG
Android uses Dalvik Virtual Machine (DVM) which requires a special bytecode format called .dex files. The DVM executes multiple virtual machines efficiently and runs Java bytecode, converting it to .dex format. Activities dictate the user interface and handle interactions, services handle background processes, broadcast receivers handle communication between apps and the OS, and content providers manage data storage. The Android SDK includes tools like the emulator, DDMS, and ADB for app development.
The document discusses the steps for learning Android application development, including downloading the necessary tools like Java SDK, Eclipse IDE, and Android SDK. It covers key Android concepts like application components, user interfaces, and the AndroidManifest file. It also explains how to create a basic Android app by constructing the UI, adding logic in Java, and publishing the app on the Android Market after testing.
Day: 2 Environment Setup for Android Application DevelopmentAhsanul Karim
The document provides an overview of setting up the development environment for Android application development. It discusses installing the Java Development Kit (JDK), Eclipse IDE, Android SDK, and ADT plugin. It then demonstrates creating a "Hello World" Android app in Eclipse to introduce application structure, components, and the building blocks of an Android app.
Android Workshop for NTU. A getting started guide to android application development.
UPDATE (Oct 2013): An updated slide at http://samwize.com/2013/10/13/android-workshop-2013/
The document discusses Android platform development. It provides an overview of Android, the development tools including the Android SDK, emulator limitations, and Eclipse plugin. It describes Android applications, activities, intents, services, and notifications. It also discusses building application user interfaces with XML layouts and views, and applications' behavior in the Android system as defined in the AndroidManifest file.
The Key to Digital Success_ A Comprehensive Guide to Continuous Testing Integ...kalichargn70th171
In today's business landscape, digital integration is ubiquitous, demanding swift innovation as a necessity rather than a luxury. In a fiercely competitive market with heightened customer expectations, the timely launch of flawless digital products is crucial for both acquisition and retention—any delay risks ceding market share to competitors.
Mobile App Development Company In Noida | Drona InfotechDrona Infotech
Drona Infotech is a premier mobile app development company in Noida, providing cutting-edge solutions for businesses.
Visit Us For : https://www.dronainfotech.com/mobile-application-development/
Everything You Need to Know About X-Sign: The eSign Functionality of XfilesPr...XfilesPro
Wondering how X-Sign gained popularity in a quick time span? This eSign functionality of XfilesPro DocuPrime has many advancements to offer for Salesforce users. Explore them now!
How Can Hiring A Mobile App Development Company Help Your Business Grow?ToXSL Technologies
ToXSL Technologies is an award-winning Mobile App Development Company in Dubai that helps businesses reshape their digital possibilities with custom app services. As a top app development company in Dubai, we offer highly engaging iOS & Android app solutions. https://rb.gy/necdnt
14 th Edition of International conference on computer visionShulagnaSarkar2
About the event
14th Edition of International conference on computer vision
Computer conferences organized by ScienceFather group. ScienceFather takes the privilege to invite speakers participants students delegates and exhibitors from across the globe to its International Conference on computer conferences to be held in the Various Beautiful cites of the world. computer conferences are a discussion of common Inventions-related issues and additionally trade information share proof thoughts and insight into advanced developments in the science inventions service system. New technology may create many materials and devices with a vast range of applications such as in Science medicine electronics biomaterials energy production and consumer products.
Nomination are Open!! Don't Miss it
Visit: computer.scifat.com
Award Nomination: https://x-i.me/ishnom
Conference Submission: https://x-i.me/anicon
For Enquiry: Computer@scifat.com
Preparing Non - Technical Founders for Engaging a Tech AgencyISH Technologies
Preparing non-technical founders before engaging a tech agency is crucial for the success of their projects. It starts with clearly defining their vision and goals, conducting thorough market research, and gaining a basic understanding of relevant technologies. Setting realistic expectations and preparing a detailed project brief are essential steps. Founders should select a tech agency with a proven track record and establish clear communication channels. Additionally, addressing legal and contractual considerations and planning for post-launch support are vital to ensure a smooth and successful collaboration. This preparation empowers non-technical founders to effectively communicate their needs and work seamlessly with their chosen tech agency.Visit our site to get more details about this. Contact us today www.ishtechnologies.com.au
Hand Rolled Applicative User ValidationCode KataPhilip Schwarz
Could you use a simple piece of Scala validation code (granted, a very simplistic one too!) that you can rewrite, now and again, to refresh your basic understanding of Applicative operators <*>, <*, *>?
The goal is not to write perfect code showcasing validation, but rather, to provide a small, rough-and ready exercise to reinforce your muscle-memory.
Despite its grandiose-sounding title, this deck consists of just three slides showing the Scala 3 code to be rewritten whenever the details of the operators begin to fade away.
The code is my rough and ready translation of a Haskell user-validation program found in a book called Finding Success (and Failure) in Haskell - Fall in love with applicative functors.
Unveiling the Advantages of Agile Software Development.pdfbrainerhub1
Learn about Agile Software Development's advantages. Simplify your workflow to spur quicker innovation. Jump right in! We have also discussed the advantages.
1. Tutorial: Setup for
Android Development
Adam C. Champion
CSE 5236: Mobile Application Development
Autumn 2014
Based on material from C. Horstmann [1], J. Bloch [2], C. Collins et al. [4],
M.L. Sichitiu (NCSU), V. Janjic (Imperial College London), CSE 2221 (OSU), and other sources
1
3. Getting Started (1)
• Need to install Java Development Kit (JDK) to write
Java (and Android) programs
– Do not install Java Runtime Environment (JRE);
JDK and JRE are different!
• Can download the JDK for your OS at http://java.oracle.com
• Alternatively, for OS X, Linux:
– OS X:
• Open /Applications/Utilities/Terminal.app
• Type javac at command line
• Install Java when prompt appears
– Linux:
• Type sudo
apt–get
install
default–jdk at command line
(Debian, Ubuntu)
• Other distributions: consult distribution’s documentation
3
5. Getting Started (2)
• After installing JDK, download Android SDK
from http://developer.android.com
• Simplest: download and install Android Studio
bundle (including Android SDK) for your OS
• Alternatives:
– Download/install Android Developer Tools from this
site (based on Eclipse)
– Install Android SDK tools by themselves, then install
ADT for Eclipse separately (from this site)
• We’ll use Android Studio with SDK included
(easy)
5
7. Getting Started (3)
• Install Android Studio directly (Windows, Mac); unzip to directory
android-‐studio, then run ./android-‐studio/bin/studio.sh (Linux)
• You should see this:
7
8. Getting Started (4)
• Strongly recommend testing
with real Android device
– Android emulator: very slow
– Faster emulator: Genymotion
[14], [15]
– Install USB drivers for your
Android device!
• Bring up the Android SDK
Manager
– Recommended: Install
Android 2.2, 2.3.3 APIs and
4.x API
– Do not worry about Intel x86
Atom, MIPS system images
Settings
Now you’re ready for Android development!
8
10. Introduction to Android
• Popular mobile device
OS: 52% of U.S.
smartphone market [8]
• Developed by Open
Handset Alliance, led by
Google
• Google claims 900,000
Android device
activations [9]
Source: [8]
10
12. Android Highlights (1)
• Android apps execute on
Dalvik VM, a “clean-room”
implementation of JVM
– Dalvik optimized for efficient
execution
– Dalvik: register-based VM,
unlike Oracle’s stack-based
JVM
– Java .class bytecode translated
to Dalvik EXecutable (DEX)
bytecode, which Dalvik
interprets
12
13. Android Highlights (2)
• Android apps written in Java 5
– Actually, a Java dialect (Apache Harmony)
– Everything we’ve learned still holds
• Apps use four main components:
– Activity: A “single screen” that’s visible to user
– Service: Long-running background “part” of app (not
separate process or thread)
– ContentProvider: Manages app data (usually stored in
database) and data access for queries
– BroadcastReceiver: Component that listens for particular
Android system “events”, e.g., “found wireless device”,
and responds accordingly
13
14. App Manifest
• Every Android app must include an
AndroidManifest.xml file describing functionality
• The manifest specifies:
– App’s Activities, Services, etc.
– Permissions requested by app
– Minimum API required
– Hardware features required, e.g., camera with
autofocus
– External libraries to which app is linked, e.g., Google
Maps library
14
15. Activity Lifecycle
• Activity: key building
block of Android apps
• Extend Activity class,
override onCreate(),
onPause(), onResume()
methods
• Dalvik VM can stop any
Activity without warning,
so saving state is important!
• Activities need to be
“responsive”, otherwise
Android shows user “App
Not Responsive” warning:
– Place lengthy operations in
Runnable Threads,
AsyncTasks
Source: [12]
15
16. App Creation Checklist
• If you own an Android device:
– Ensure drivers are installed
– Enable developer options on device under Settings,
specifically USB Debugging
• Android 4.2+: Go to Settings→About phone, press Build number 7
times to enable developer options
• For Android Studio:
– Under File→Settings→Appearance, enable “Show tool
window bars”; the Android view shows LogCat, devices
– Programs should log states via android.util.Log’s
Log.d(APP_TAG_STR,
“debug”), where APP_TAG_STR is a
final String tag denoting your app
– Other commands: Log.e() (error); Log.i() (info); Log.w()
(warning); Log.v() (verbose) – same parameters 16
17. Creating Android App (1)
• Creating Android app
project in Android
Studio:
– Go to File→New Project
– Enter app, project name
– Choose package name
using “reverse URL”
notation, e.g.,
edu.osu.myapp
– Select APIs for app, then
click Next
17
18. Creating Android App (2)
• Determine what kind of
Activity to create; then
click Next
– We’ll choose a Blank
Activity for simplicity
• Enter information about
your Activity, then click
Finish
• This creates a “Hello
World” app
18
19. Deploying the App
• Two choices for deployment:
– Real Android device
– Android virtual device
• Plug in your real device;
otherwise, create an Android
virtual device
• Emulator is slow. Try Intel
accelerated version, or perhaps
http://www.genymotion.com/
• Run the app: press “Run”
button in toolbar
19
20. Underlying Source Code
package
edu.osu.helloandroid;
import
android.os.Bundle;
import
android.app.Activity;
import
android.view.Menu;
public
class
MainActivity
extends
Activity
{
@Override
protected
void
onCreate(Bundle
savedInstanceState)
{
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
}
@Override
public
boolean
onCreateOptionsMenu(Menu
menu)
{
//
Inflate
the
menu;
this
adds
items
to
the
action
bar
if
it
is
present.
getMenuInflater().inflate(R.menu.main,
menu);
return
true;
}
}
src/…/MainActivity.java
20
23. A More Interesting App
• We’ll now examine an
app with more features:
WiFi Tester (code on
class website)
• Press a button, scan for
WiFi access points
(APs), display them
23
24. Underlying Source Code (1)
@Override
public
void
onCreate(Bundle
savedInstanceState)
{
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_wi_fi);
//
Set
up
WifiManager.
mWifiManager
=
(WifiManager)
getSystemService(Context.WIFI_SERVICE);
//
Create
listener
object
for
Button.
When
Button
is
pressed,
scan
for
//
APs
nearby.
Button
button
=
(Button)
findViewById(R.id.button);
button.setOnClickListener(new
View.OnClickListener()
{
public
void
onClick(View
v)
{
boolean
scanStarted
=
mWifiManager.startScan();
//
If
the
scan
failed,
log
it.
if
(!scanStarted)
Log.e(TAG,
"WiFi
scan
failed...");
}
});
//
Set
up
IntentFilter
for
"WiFi
scan
results
available"
Intent.
mIntentFilter
=
new
IntentFilter();
mIntentFilter.addAction(WifiManager.SCAN_RESULTS_AVAILABLE_ACTION);
}
24
25. Underlying Source Code (2)
• Code much more complex
• First get system WifiManager
• Create listener Object for button that
performs scans
• We register Broadcast Receiver,
mReceiver, to listen for
WifiManager’s “finished scan” system
event (expressed as Intent
WifiManager.SCAN_RESULTS_
AVAILABLE_ACTION)
• Unregister Broadcast Receiver when
leaving Activity
@Override
protected
void
onResume()
{
super.onResume();
registerReceiver(mReceiver,
mIntentFilter);
}
@Override
protected
void
onPause()
{
super.onPause();
unregisterReceiver(mReceiver);
}
25
26. The Broadcast Receiver
private
final
BroadcastReceiver
mReceiver
=
new
BroadcastReceiver()
{
@Override
public
void
onReceive(Context
context,
Intent
intent)
{
String
action
=
intent.getAction();
if
(WifiManager.SCAN_RESULTS_AVAILABLE_ACTION.equals(action))
{
Log.e(TAG,
"Scan
results
available");
List<ScanResult>
scanResults
=
mWifiManager.getScanResults();
mApStr
=
"";
for
(ScanResult
result
:
scanResults)
{
mApStr
=
mApStr
+
result.SSID
+
";
";
mApStr
=
mApStr
+
result.BSSID
+
";
";
mApStr
=
mApStr
+
result.capabilities
+
";
";
mApStr
=
mApStr
+
result.frequency
+
"
MHz;";
mApStr
=
mApStr
+
result.level
+
"
dBmnn";
}
//
Update
UI
to
show
all
this
information.
setTextView(mApStr);
}
}
};
26
27. User Interface
Updating UI in code
private
void
setTextView(String
str)
{
TextView
tv
=
(TextView)
findViewById(R.id.textview);
tv.setMovementMethod(new
ScrollingMovementMethod());
tv.setText(str);
}
• This code simply has the UI display
all collected WiFi APs, makes the
text information scrollable
UI Layout (XML)
<LinearLayout
xmlns:android="http://schemas.android.com/apk/
res/android"
xmlns:tools="http://schemas.android.com/tools"
android:layout_width="fill_parent"
android:layout_height="fill_parent"
android:orientation="vertical">
<Button
android:layout_width="fill_parent"
android:layout_height="wrap_content"
android:id="@+id/button"
android:text="@string/button_text"/>
<TextView
android:id="@+id/header"
android:layout_width="fill_parent"
android:layout_height="wrap_content"
android:text="@string/ap_list"
tools:context=".WiFiActivity"
android:textStyle="bold"
android:gravity="center">
</TextView>
<TextView
android:layout_width="fill_parent"
android:layout_height="fill_parent"
tools:context=".WiFiActivity"
android:id="@+id/textview"
android:scrollbars="vertical">
</TextView>
</LinearLayout>
27
28. Android Programming Notes
• Android apps have multiple points of entry: no main() method
– Cannot “sleep” in Android
– During each entrance, certain Objects may be null
– Defensive programming is very useful to avoid crashes, e.g.,
if
(!(myObj
==
null))
{
//
do
something
}
• Java concurrency techniques are required
– Don’t block the “main” thread in Activities
– Implement long-running tasks such as network connections
asynchronously, e.g., as AsyncTasks
– Recommendation: read [4]; chapter 20 [10]; [11]
• Logging state via android.util.Log throughout app is essential
when debugging (finding root causes)
• Better to have “too many” permissions than too few
– Otherwise, app crashes due to security exceptions!
– Remove “unnecessary” permissions before releasing app to public
• Event handling in Android GUIs entails many listener Objects
28
29. Concurrency: Threads (1)
• Thread: program unit (within process) executing independently
• Basic idea: create class that implements Runnable interface
– Runnable has one method, run(), that contains code to be executed
– Example:
public
class
OurRunnable
implements
Runnable
{
public
void
run()
{
//
run
code
}
}
• Create a Thread object from Runnable and start() Thread, e.g.,
Runnable
r
=
new
OurRunnable();
Thread
t
=
new
Thread(r);
t.start();
• Problem: this is cumbersome unless Thread code is reused
29
30. Concurrency: Threads (2)
• Easier approach: anonymous inner classes, e.g.,
Thread
t
=
new
Thread(new
Runnable(
{
public
void
run()
{
//
code
to
run
}
});
t.start();
• Idiom essential for one-time network connections in
Activities
• However, Threads can be difficult to synchronize,
especially with UI thread in Activity. AsyncTasks are
better suited for this
30
31. Concurrency: AsyncTasks
• AsyncTask encapsulates asynchronous task that interacts with UI thread
in Activity:
public
class
AsyncTask<Params,
Progress,
Result>
{
protected
Result
doInBackground(ParamType
param)
{
//
code
to
run
in
background
publishProgress(ProgressType
progress);
//
UI
…
return
Result;
}
protected
void
onProgressUpdate(ProgressType
progress)
{
//
invoke
method
in
Activity
to
update
UI
}
}
• Extend AsyncTask with your own class
• Documentation at http://developer.android.com
31
33. References (1)
1. C. Horstmann, Big Java Late Objects, Wiley, 2012. Online: http://proquest.safaribooksonline.
com.proxy.lib.ohio–state.edu/book/–/9781118087886
2. J. Bloch, Effective Java, 2nd ed., Addison–Wesley, 2008. Online: http://proquest.
safaribooksonline.com.proxy.lib.ohio–state.edu/book/programming/java/9780137150021
3. S.B. Zakhour, S. Kannan, and R. Gallardo, The Java® Tutorial: A Short Course on the Basics,
5th ed., Addison–Wesley, 2013. Online: http://proquest.safaribooksonline.com.proxy.lib.
ohio–state.edu/book/programming/java/9780132761987
4. C. Collins, M. Galpin, and M. Kaeppler, Android in Practice, Manning, 2011. Online:
http://proquest.safaribooksonline.com.proxy.lib.ohio–state.edu/book/programming/android/
9781935182924
5. M.L. Sichitiu, 2011, http://www.ece.ncsu.edu/wireless/MadeInWALAN/AndroidTutorial/PPTs/
javaReview.ppt
6. Oracle, http://docs.oracle.com/javase/1.5.0/docs/api/index.html
7. Wikipedia, https://en.wikipedia.org/wiki/Vehicle_Identification_Number
8. Nielsen Co., “Smartphone Milestone: Half of Mobile Subscribers Ages 55+ Own
Smartphones”, 22 Apr. 2014, http://www.nielsen.com/us/en/insights/news/2014/
smartphone-milestone-half-of-americans-ages-55-own-smartphones.html
9. Android Open Source Project, http://www.android.com
33
34. References (2)
10. http://bcs.wiley.com/he-bcs/Books?action=index&itemId=1118087887&bcsId=7006
11. B. Goetz, T. Peierls, J. Bloch, J. Bowbeer, D. Holmes, and D. Lea, Java Concurrency in
Practice, Addison-Wesley, 2006, online at
http://proquest.safaribooksonline.com/book/programming/java/0321349601
12. https://developer.android.com/guide/components/activities.html
13. https://developer.android.com/guide/topics/ui/declaring-layout.html#CommonLayouts
14. https://cloud.genymotion.com/page/doc/#collapse4
15. http://blog.zeezonline.com/2013/11/install-google-play-on-genymotion-2-0/
34