How to incorporate Spinners into your Android App and populate them using Adapters.
The second half of this lesson details the basics of how to make fragments communicate with each other within an Android App.
Making ethernet cable (cable pinouts, tools and equipment)ArjonDando1
There are two types of Ethernet cable: straight through cable and crossover cable. Straight through cable uses the same pinout configuration on both ends and is used to connect devices to switches or routers. Crossover cable uses a different pinout configuration on each end to directly connect two devices without a networking device. The document also describes the tools needed to make Ethernet cables, including crimping tools, wire strippers, and network cable testers.
The document discusses cable crimping and testing for RJ45 cables. It explains the difference between straight and crossover cables and the different wiring schematics used for each. It provides steps for crimping an RJ45 connector onto a cable, including stripping the cable, inserting the wires into the connector, crimping it, and testing the connection.
1. Ethernet cables are used to connect devices in a computer network and come in several categories like Cat5, Cat5e, and Cat6, with higher categories supporting faster data transmission speeds.
2. Ethernet cables have four twisted pairs of wires in orange, green, blue, and brown and pins are designated according to the T568B standard.
3. Straight-through cables have wiring that matches pin to pin on each end, while crossover cables swap the transmit and receive pins to connect like devices such as computers.
This document provides an overview of the math module in Python. It demonstrates how to import the math module and use common mathematical constants like pi and e. It also shows various math functions for calculating ceilings, floors, factorials, powers, square roots, logarithms, exponents, and converting between radians and degrees. The document contains examples of using these math functions and provides a brief description of their usage.
Resume Sandip kandari 3 years automation testing Sandip Kandari
This document contains the resume of Sandip Singh Kandari, who has over 3 years of experience in information technology and software testing. He has expertise in test automation using Selenium and experience in test frameworks like TestNG and JUnit. He is proficient in quality assurance tools like Quality Center and Jira. Some of the key projects he has worked on are for HSBC Bank and Global Service Platform for Capgemini. He is certified in ISTQB foundation level testing and agile testing.
The document provides an introduction to Python programming. It discusses that Python is a high-level, interpreted, object-oriented, and general purpose programming language. It can be used for web development, scientific computing, desktop applications, and more. The document then covers Python basics like data types, variables, literals, operators, control flow statements, functions, modules and packages. It also discusses installing Python on Windows and writing the first Python program.
Making ethernet cable (cable pinouts, tools and equipment)ArjonDando1
There are two types of Ethernet cable: straight through cable and crossover cable. Straight through cable uses the same pinout configuration on both ends and is used to connect devices to switches or routers. Crossover cable uses a different pinout configuration on each end to directly connect two devices without a networking device. The document also describes the tools needed to make Ethernet cables, including crimping tools, wire strippers, and network cable testers.
The document discusses cable crimping and testing for RJ45 cables. It explains the difference between straight and crossover cables and the different wiring schematics used for each. It provides steps for crimping an RJ45 connector onto a cable, including stripping the cable, inserting the wires into the connector, crimping it, and testing the connection.
1. Ethernet cables are used to connect devices in a computer network and come in several categories like Cat5, Cat5e, and Cat6, with higher categories supporting faster data transmission speeds.
2. Ethernet cables have four twisted pairs of wires in orange, green, blue, and brown and pins are designated according to the T568B standard.
3. Straight-through cables have wiring that matches pin to pin on each end, while crossover cables swap the transmit and receive pins to connect like devices such as computers.
This document provides an overview of the math module in Python. It demonstrates how to import the math module and use common mathematical constants like pi and e. It also shows various math functions for calculating ceilings, floors, factorials, powers, square roots, logarithms, exponents, and converting between radians and degrees. The document contains examples of using these math functions and provides a brief description of their usage.
Resume Sandip kandari 3 years automation testing Sandip Kandari
This document contains the resume of Sandip Singh Kandari, who has over 3 years of experience in information technology and software testing. He has expertise in test automation using Selenium and experience in test frameworks like TestNG and JUnit. He is proficient in quality assurance tools like Quality Center and Jira. Some of the key projects he has worked on are for HSBC Bank and Global Service Platform for Capgemini. He is certified in ISTQB foundation level testing and agile testing.
The document provides an introduction to Python programming. It discusses that Python is a high-level, interpreted, object-oriented, and general purpose programming language. It can be used for web development, scientific computing, desktop applications, and more. The document then covers Python basics like data types, variables, literals, operators, control flow statements, functions, modules and packages. It also discusses installing Python on Windows and writing the first Python program.
This document provides information about memoirs and personal narratives. It defines a memoir as a short, reflective piece of autobiographical nonfiction focused on a single meaningful event or time period in the author's life. Memoirs have the purpose of revealing something important about the author or their experience, leaving something of themselves behind, bearing witness to an event, or learning something about themselves. The document outlines characteristics of memoirs, such as being written in first person and focusing on truth, feelings, meaning, and a unique experience. It emphasizes showing rather than telling and using vivid language to create a picture for the reader. Students are then assigned to write a partial autobiography focused on a specific period of their own life.
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.
This document provides an overview of fragments and multiple layouts in Android app development. It discusses using string resources, introducing fragments, creating and adding fragments, and the fragment lifecycle. It explains that fragments allow dividing the screen into independent sections that can be reused across activities. The document demonstrates creating a main fragment class and layout, and adding the fragment to an activity's layout. It also discusses using different layouts for different screen sizes and orientations through configuration qualifiers.
Android 101 - Introduction to Android DevelopmentAndy Scherzinger
This document provides an introduction to Android development. It covers topics such as setting up the development environment, understanding the file system structure, using activities and fragments, handling fragmentation across different devices, and some best practices. The document discusses tools like Android Studio, the build system, and debugging tools. It also explains concepts like the activity lifecycle, saving activity state, targeting different versions and configurations, and using support libraries for backwards compatibility.
This talk is paired with a live coding exercise which adds an additional 20min to the presentation. The coding exercise deep dives into how to communicate with fragments.
Fragments allow dividing the graphical interface of an activity into independent and reusable modules. A fragment has its own lifecycle and can be dynamically added or removed from an activity during runtime. Communication between a fragment and its activity can occur through interfaces or by accessing the activity from within the fragment. Fragments help create flexible and adaptable user interfaces for different screen sizes and configurations.
The document discusses working with fragments in Android. It provides an overview of fragments, when to use them, how to manage fragments using FragmentManager and FragmentTransactions, and how to add fragments both statically and dynamically. It also covers fragment operations like adding, removing, replacing fragments as well as using the back stack with fragments. The document includes examples and demos of fragments with activities, action bar navigation, view pagers, and navigation drawers.
This document discusses different types of screen orientations in Android including portrait and landscape. It provides 6 examples of how to detect orientation changes at runtime, lock an activity to a single orientation, switch orientations in the emulator and eclipse, and make an app support different screen resolutions.
Android - Preventing common memory leaksAli Muzaffar
The document discusses common causes of and solutions to memory leaks in Android applications. It covers issues related to using the correct Context, holding references to activities from outside their scope, non-static inner classes holding implicit references to their outer class, threads not being garbage collected, and forgetting to recycle bitmaps. The key recommendations are to always use Application Context when possible, avoid leaking references between scopes, make handlers and inner classes static when possible, implement cancellation for threads, and properly recycle bitmaps.
Fragments allow modular sections to be added and removed from an activity at runtime. A fragment has its own layout and lifecycle methods similar to an activity. The document discusses how to create and manage fragments, communicate between fragments through the activity, and dynamically change the UI based on device configuration using different layouts for portrait, landscape, and larger screens. Fragments provide a flexible way to customize the user interface on different devices.
Fragments allow modularization of activities on larger screens like tablets. A fragment represents a behavior or UI portion and has its own lifecycle callbacks. Fragments can be placed in an activity layout via XML or added dynamically in code. Multiple fragments can be combined in a single activity to build a multi-pane UI. The activity lifecycle influences fragments, and fragments can be retained across configuration changes using setRetainInstance(true).
Android Training (Storing & Shared Preferences)Khaled Anaqwa
The document discusses various options for storing data in Android applications, including shared preferences, internal storage, external storage, SQLite databases, and network connections. It provides details on how to use shared preferences to store private primitive data in key-value pairs, including initialization, storing and retrieving data, and clearing data. It also covers using internal storage to privately save files on the device memory.
Fragments allow modular and reusable components in an Android application. They are portions of UI for an activity that have their own lifecycle and can be added or removed during runtime. The key aspects are:
- Fragments were introduced in Android 3.0 but can be used in older versions with the compatibility library.
- Their lifecycle is directly tied to the host activity - pausing/destroying the activity also pauses/destroys fragments.
- They are defined as subclasses of Fragment and implement lifecycle methods like onCreateView to define the UI.
- Fragments can be added to activities declaratively in XML layouts or programmatically using transactions.
- The document discusses Android app development lessons including app lifecycles, bundles, and event handling. It describes how to save app state using bundles during configuration changes and restarts. It also explains how to add click and text change listeners to buttons, text views and edit texts to handle user interaction events.
MAD-Lec8 Spinner Adapater and Intents (1).pptAnsarAhmad57
The document discusses Spinners (drop-down lists) in Android application development. It provides two ways to create Spinners - using an XML array or programmatically with an Adapter. It also includes code samples to define a Spinner in XML, create an Adapter, populate the Spinner, and handle item selection events.
The document discusses functions in Python. It defines a function as a block of code that performs a specific task and can be called when needed. Functions make code reusable, readable, and help divide programs into modular pieces. The document covers built-in functions, user-defined functions, passing arguments to functions, scope of variables, mutable and immutable objects, and functions available in Python libraries like math and string functions.
The document discusses several new features and APIs in Android 3.0 (Honeycomb) for tablets, including fragments which allow recomposing UI based on factors like screen size, loaders for asynchronously fetching content, an enhanced action bar for navigation and menus, hardware accelerated graphics, and the new holographic UI design. It also questions what some aspects of Android 3.0 may mean for future phone releases and how to detect "tablet-y" systems.
Java is an object-oriented programming language created by James Gosling at Sun Microsystems in 1995. It is platform independent, meaning programs written in Java can run on any system that supports Java without needing to be recompiled. The document provides an overview of Java, including its history and development, basic concepts like classes and objects, and how to write simple Java programs. It also discusses Java's advantages like being simple, object-oriented, portable, multithreaded, and secure.
This document provides information about memoirs and personal narratives. It defines a memoir as a short, reflective piece of autobiographical nonfiction focused on a single meaningful event or time period in the author's life. Memoirs have the purpose of revealing something important about the author or their experience, leaving something of themselves behind, bearing witness to an event, or learning something about themselves. The document outlines characteristics of memoirs, such as being written in first person and focusing on truth, feelings, meaning, and a unique experience. It emphasizes showing rather than telling and using vivid language to create a picture for the reader. Students are then assigned to write a partial autobiography focused on a specific period of their own life.
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.
This document provides an overview of fragments and multiple layouts in Android app development. It discusses using string resources, introducing fragments, creating and adding fragments, and the fragment lifecycle. It explains that fragments allow dividing the screen into independent sections that can be reused across activities. The document demonstrates creating a main fragment class and layout, and adding the fragment to an activity's layout. It also discusses using different layouts for different screen sizes and orientations through configuration qualifiers.
Android 101 - Introduction to Android DevelopmentAndy Scherzinger
This document provides an introduction to Android development. It covers topics such as setting up the development environment, understanding the file system structure, using activities and fragments, handling fragmentation across different devices, and some best practices. The document discusses tools like Android Studio, the build system, and debugging tools. It also explains concepts like the activity lifecycle, saving activity state, targeting different versions and configurations, and using support libraries for backwards compatibility.
This talk is paired with a live coding exercise which adds an additional 20min to the presentation. The coding exercise deep dives into how to communicate with fragments.
Fragments allow dividing the graphical interface of an activity into independent and reusable modules. A fragment has its own lifecycle and can be dynamically added or removed from an activity during runtime. Communication between a fragment and its activity can occur through interfaces or by accessing the activity from within the fragment. Fragments help create flexible and adaptable user interfaces for different screen sizes and configurations.
The document discusses working with fragments in Android. It provides an overview of fragments, when to use them, how to manage fragments using FragmentManager and FragmentTransactions, and how to add fragments both statically and dynamically. It also covers fragment operations like adding, removing, replacing fragments as well as using the back stack with fragments. The document includes examples and demos of fragments with activities, action bar navigation, view pagers, and navigation drawers.
This document discusses different types of screen orientations in Android including portrait and landscape. It provides 6 examples of how to detect orientation changes at runtime, lock an activity to a single orientation, switch orientations in the emulator and eclipse, and make an app support different screen resolutions.
Android - Preventing common memory leaksAli Muzaffar
The document discusses common causes of and solutions to memory leaks in Android applications. It covers issues related to using the correct Context, holding references to activities from outside their scope, non-static inner classes holding implicit references to their outer class, threads not being garbage collected, and forgetting to recycle bitmaps. The key recommendations are to always use Application Context when possible, avoid leaking references between scopes, make handlers and inner classes static when possible, implement cancellation for threads, and properly recycle bitmaps.
Fragments allow modular sections to be added and removed from an activity at runtime. A fragment has its own layout and lifecycle methods similar to an activity. The document discusses how to create and manage fragments, communicate between fragments through the activity, and dynamically change the UI based on device configuration using different layouts for portrait, landscape, and larger screens. Fragments provide a flexible way to customize the user interface on different devices.
Fragments allow modularization of activities on larger screens like tablets. A fragment represents a behavior or UI portion and has its own lifecycle callbacks. Fragments can be placed in an activity layout via XML or added dynamically in code. Multiple fragments can be combined in a single activity to build a multi-pane UI. The activity lifecycle influences fragments, and fragments can be retained across configuration changes using setRetainInstance(true).
Android Training (Storing & Shared Preferences)Khaled Anaqwa
The document discusses various options for storing data in Android applications, including shared preferences, internal storage, external storage, SQLite databases, and network connections. It provides details on how to use shared preferences to store private primitive data in key-value pairs, including initialization, storing and retrieving data, and clearing data. It also covers using internal storage to privately save files on the device memory.
Fragments allow modular and reusable components in an Android application. They are portions of UI for an activity that have their own lifecycle and can be added or removed during runtime. The key aspects are:
- Fragments were introduced in Android 3.0 but can be used in older versions with the compatibility library.
- Their lifecycle is directly tied to the host activity - pausing/destroying the activity also pauses/destroys fragments.
- They are defined as subclasses of Fragment and implement lifecycle methods like onCreateView to define the UI.
- Fragments can be added to activities declaratively in XML layouts or programmatically using transactions.
- The document discusses Android app development lessons including app lifecycles, bundles, and event handling. It describes how to save app state using bundles during configuration changes and restarts. It also explains how to add click and text change listeners to buttons, text views and edit texts to handle user interaction events.
MAD-Lec8 Spinner Adapater and Intents (1).pptAnsarAhmad57
The document discusses Spinners (drop-down lists) in Android application development. It provides two ways to create Spinners - using an XML array or programmatically with an Adapter. It also includes code samples to define a Spinner in XML, create an Adapter, populate the Spinner, and handle item selection events.
The document discusses functions in Python. It defines a function as a block of code that performs a specific task and can be called when needed. Functions make code reusable, readable, and help divide programs into modular pieces. The document covers built-in functions, user-defined functions, passing arguments to functions, scope of variables, mutable and immutable objects, and functions available in Python libraries like math and string functions.
The document discusses several new features and APIs in Android 3.0 (Honeycomb) for tablets, including fragments which allow recomposing UI based on factors like screen size, loaders for asynchronously fetching content, an enhanced action bar for navigation and menus, hardware accelerated graphics, and the new holographic UI design. It also questions what some aspects of Android 3.0 may mean for future phone releases and how to detect "tablet-y" systems.
Java is an object-oriented programming language created by James Gosling at Sun Microsystems in 1995. It is platform independent, meaning programs written in Java can run on any system that supports Java without needing to be recompiled. The document provides an overview of Java, including its history and development, basic concepts like classes and objects, and how to write simple Java programs. It also discusses Java's advantages like being simple, object-oriented, portable, multithreaded, and secure.
This document provides an overview of key Android concepts including:
- Android's history and version timeline from 1.0 to Oreo.
- The Android activity lifecycle including methods like onCreate(), onStart(), onResume(), etc.
- What fragments are in Android and their core lifecycle methods.
- Different types of layouts that can be used in an Android app like RelativeLayout, LinearLayout, etc.
- How to integrate APIs and handle network requests and responses in an Android app.
It also provides code examples and tips for beginners on resources for learning Android development.
An interface defines a collection of abstract methods that can be implemented by classes. A class implements the interface to inherit its abstract methods and define their behavior. An interface cannot be instantiated on its own but defines common behaviors for other classes to use. A use case diagram models system functions through actors and use cases, where actors represent roles that interact with the system and use cases specify system actions. Relationships like association, dependency, extend and include define interactions between actors and use cases.
The document discusses events, creating custom events, and processing event streams in F#. It provides an overview of events, how they allow objects to communicate asynchronously, and how to create and handle events through the Event class. It also covers creating custom events for a Worker class to notify when the name or shift changes, attaching callback functions to event handlers, and an example of implementing an interface using events.
This is a basic crash course for android development covers:
Android Studio,Hello World Application,Application Components,Application Resources,User Interface,Good UI,Play Store
This document provides an overview of key Android development concepts and techniques. It discusses fragments, the support library, dependency injection, image caching, threading and AsyncTask, notifications, supporting multiple screens, and optimizing ListView performance. The document also recommends several popular Android libraries and open source apps that demonstrate best practices.
Flutter Installation document provides instructions on:
- Installing Flutter SDK and configuring environment variables on Windows.
- Creating a simple Flutter project in Android Studio.
- Describing the basic folder structure of a Flutter project.
- Introducing some Dart language basics like variables, functions, lists, and maps.
The document provides an agenda for a MuleSoft meetup in Baltimore. It includes an introduction, a discussion on JSON logging and frameworks in MuleSoft, a demo, and a Q&A section. It also outlines a trivia/quiz with a prize for winners and seeks feedback on upcoming events. The meetup speaker is introduced and their experience shared.
This document provides an overview of using DroidDraw, a user interface designer for Android applications. It discusses how DroidDraw allows dragging and dropping widgets onto a screen layout to build a UI visually. Key aspects covered include choosing root layouts like LinearLayout, setting screen size, generating XML code from the designed UI, and exploring different tabs for layouts, properties, strings, and more. The document also provides a brief introduction to key concepts in Android like activities, services, content providers and resources.
Android is an open source platform developed by Google and the Open Handset Alliance for mobile devices. It consists of an operating system, middleware, and key applications. The document provides an overview of Android versions from 1.1 to 4.1 Jelly Bean and their market shares. It also discusses installing the Android Development Tools plugin for Eclipse, exploring a sample project's components, and developing applications considering different Android versions. The sample project demonstrates creating layouts, handling button clicks, launching a new activity, and registering activities in the manifest file.
Similar to Spinners, Adapters & Fragment Communication (20)
GraphSummit Paris - The art of the possible with Graph TechnologyNeo4j
Sudhir Hasbe, Chief Product Officer, Neo4j
Join us as we explore breakthrough innovations enabled by interconnected data and AI. Discover firsthand how organizations use relationships in data to uncover contextual insights and solve our most pressing challenges – from optimizing supply chains, detecting fraud, and improving customer experiences to accelerating drug discoveries.
Atelier - Innover avec l’IA Générative et les graphes de connaissancesNeo4j
Atelier - Innover avec l’IA Générative et les graphes de connaissances
Allez au-delà du battage médiatique autour de l’IA et découvrez des techniques pratiques pour utiliser l’IA de manière responsable à travers les données de votre organisation. Explorez comment utiliser les graphes de connaissances pour augmenter la précision, la transparence et la capacité d’explication dans les systèmes d’IA générative. Vous partirez avec une expérience pratique combinant les relations entre les données et les LLM pour apporter du contexte spécifique à votre domaine et améliorer votre raisonnement.
Amenez votre ordinateur portable et nous vous guiderons sur la mise en place de votre propre pile d’IA générative, en vous fournissant des exemples pratiques et codés pour démarrer en quelques minutes.
Using Query Store in Azure PostgreSQL to Understand Query PerformanceGrant Fritchey
Microsoft has added an excellent new extension in PostgreSQL on their Azure Platform. This session, presented at Posette 2024, covers what Query Store is and the types of information you can get out of it.
Flutter is a popular open source, cross-platform framework developed by Google. In this webinar we'll explore Flutter and its architecture, delve into the Flutter Embedder and Flutter’s Dart language, discover how to leverage Flutter for embedded device development, learn about Automotive Grade Linux (AGL) and its consortium and understand the rationale behind AGL's choice of Flutter for next-gen IVI systems. Don’t miss this opportunity to discover whether Flutter is right for your project.
What is Master Data Management by PiLog Groupaymanquadri279
PiLog Group's Master Data Record Manager (MDRM) is a sophisticated enterprise solution designed to ensure data accuracy, consistency, and governance across various business functions. MDRM integrates advanced data management technologies to cleanse, classify, and standardize master data, thereby enhancing data quality and operational efficiency.
UI5con 2024 - Keynote: Latest News about UI5 and it’s EcosystemPeter Muessig
Learn about the latest innovations in and around OpenUI5/SAPUI5: UI5 Tooling, UI5 linter, UI5 Web Components, Web Components Integration, UI5 2.x, UI5 GenAI.
Recording:
https://www.youtube.com/live/MSdGLG2zLy8?si=INxBHTqkwHhxV5Ta&t=0
Measures in SQL (SIGMOD 2024, Santiago, Chile)Julian Hyde
SQL has attained widespread adoption, but Business Intelligence tools still use their own higher level languages based upon a multidimensional paradigm. Composable calculations are what is missing from SQL, and we propose a new kind of column, called a measure, that attaches a calculation to a table. Like regular tables, tables with measures are composable and closed when used in queries.
SQL-with-measures has the power, conciseness and reusability of multidimensional languages but retains SQL semantics. Measure invocations can be expanded in place to simple, clear SQL.
To define the evaluation semantics for measures, we introduce context-sensitive expressions (a way to evaluate multidimensional expressions that is consistent with existing SQL semantics), a concept called evaluation context, and several operations for setting and modifying the evaluation context.
A talk at SIGMOD, June 9–15, 2024, Santiago, Chile
Authors: Julian Hyde (Google) and John Fremlin (Google)
https://doi.org/10.1145/3626246.3653374
Odoo ERP software
Odoo ERP software, a leading open-source software for Enterprise Resource Planning (ERP) and business management, has recently launched its latest version, Odoo 17 Community Edition. This update introduces a range of new features and enhancements designed to streamline business operations and support growth.
The Odoo Community serves as a cost-free edition within the Odoo suite of ERP systems. Tailored to accommodate the standard needs of business operations, it provides a robust platform suitable for organisations of different sizes and business sectors. Within the Odoo Community Edition, users can access a variety of essential features and services essential for managing day-to-day tasks efficiently.
This blog presents a detailed overview of the features available within the Odoo 17 Community edition, and the differences between Odoo 17 community and enterprise editions, aiming to equip you with the necessary information to make an informed decision about its suitability for your business.
DDS Security Version 1.2 was adopted in 2024. This revision strengthens support for long runnings systems adding new cryptographic algorithms, certificate revocation, and hardness against DoS attacks.
WhatsApp offers simple, reliable, and private messaging and calling services for free worldwide. With end-to-end encryption, your personal messages and calls are secure, ensuring only you and the recipient can access them. Enjoy voice and video calls to stay connected with loved ones or colleagues. Express yourself using stickers, GIFs, or by sharing moments on Status. WhatsApp Business enables global customer outreach, facilitating sales growth and relationship building through showcasing products and services. Stay connected effortlessly with group chats for planning outings with friends or staying updated on family conversations.
A Study of Variable-Role-based Feature Enrichment in Neural Models of CodeAftab Hussain
Understanding variable roles in code has been found to be helpful by students
in learning programming -- could variable roles help deep neural models in
performing coding tasks? We do an exploratory study.
- These are slides of the talk given at InteNSE'23: The 1st International Workshop on Interpretability and Robustness in Neural Software Engineering, co-located with the 45th International Conference on Software Engineering, ICSE 2023, Melbourne Australia
Introducing Crescat - Event Management Software for Venues, Festivals and Eve...Crescat
Crescat is industry-trusted event management software, built by event professionals for event professionals. Founded in 2017, we have three key products tailored for the live event industry.
Crescat Event for concert promoters and event agencies. Crescat Venue for music venues, conference centers, wedding venues, concert halls and more. And Crescat Festival for festivals, conferences and complex events.
With a wide range of popular features such as event scheduling, shift management, volunteer and crew coordination, artist booking and much more, Crescat is designed for customisation and ease-of-use.
Over 125,000 events have been planned in Crescat and with hundreds of customers of all shapes and sizes, from boutique event agencies through to international concert promoters, Crescat is rigged for success. What's more, we highly value feedback from our users and we are constantly improving our software with updates, new features and improvements.
If you plan events, run a venue or produce festivals and you're looking for ways to make your life easier, then we have a solution for you. Try our software for free or schedule a no-obligation demo with one of our product specialists today at crescat.io
Transform Your Communication with Cloud-Based IVR SolutionsTheSMSPoint
Discover the power of Cloud-Based IVR Solutions to streamline communication processes. Embrace scalability and cost-efficiency while enhancing customer experiences with features like automated call routing and voice recognition. Accessible from anywhere, these solutions integrate seamlessly with existing systems, providing real-time analytics for continuous improvement. Revolutionize your communication strategy today with Cloud-Based IVR Solutions. Learn more at: https://thesmspoint.com/channel/cloud-telephony
Do you want Software for your Business? Visit Deuglo
Deuglo has top Software Developers in India. They are experts in software development and help design and create custom Software solutions.
Deuglo follows seven steps methods for delivering their services to their customers. They called it the Software development life cycle process (SDLC).
Requirement — Collecting the Requirements is the first Phase in the SSLC process.
Feasibility Study — after completing the requirement process they move to the design phase.
Design — in this phase, they start designing the software.
Coding — when designing is completed, the developers start coding for the software.
Testing — in this phase when the coding of the software is done the testing team will start testing.
Installation — after completion of testing, the application opens to the live server and launches!
Maintenance — after completing the software development, customers start using the software.
E-commerce Development Services- Hornet DynamicsHornet Dynamics
For any business hoping to succeed in the digital age, having a strong online presence is crucial. We offer Ecommerce Development Services that are customized according to your business requirements and client preferences, enabling you to create a dynamic, safe, and user-friendly online store.
2. Today’s Lesson
● More UI Components - Tonight Spinners
● string-array resources
● ArrayAdapter
● Fragment to Fragment comunication
3. Previous Lesson
● Fragments - We create them statically
● String resources
● Multiple Layouts, Multiple Devices = Multiple Layout
XML files (use pre-defined names)
● android:weight should be used with LinearLayout
4. Android UI - Next Steps
● So far we’ve seen Buttons and TextView components.
The next step is Spinners, Pickers & ListView. Spinners
this week.
● Spinners are what we commonly know elsewhere as
drop-down lists.
● A typical example would be a drop down list containing
a list of countries.
● Spinners can be populated statically or dynamically.
5. Spinner Population
● If we are putting a known/pre-defined & fixed list of
values into a Spinner (e.g. List of Countries) we can use a
String array. This is static population.
● As previously mentioned Strings in our app should be
defined as String resources (in res/values/strings.xml )
● We can define String arrays in this file as well as just
<string> using the <string-array> tag.
7. Using string-array
● To use the values in the string-array we just defined
we go back to our XML UI file of our Fragment or
Activity
● As before we can add a UI component by dragging and
dropping it on the UI designer or adding it directly in
the XML file.
● Either way the XML UI tag that results is <Spinner>
● We can link the <Spinner> directly to the string-array
resource via the XML.
9. Getting value from Spinner
● By default we end up with a Spinner which looks like
this
1. This is the default type of
picker and is of type
“dropdown”
1. You can also display it as a
dialog by using the following
property in your Spinner XML
android:spinnerMode="dialog"
10. dialog Spinner mode
● We get slightly
different behaviour
from dialog mode.
● The title of the
dialog comes from
the android:prompt
property
11. Getting value from Spinner
Spinner sp1 = (Spinner)findViewById(R.id.spinner1);
String str = sp1.getSelectedItem().toString();
● It is worth mentioning at this stage that we can add an
array of anything behind a Spinner.
● This would be done programatically as opposed to
through XML for the strings we just saw.
● Presume we had an ArrayList<Person>. To get this into
our list we need an Adapter.
12. What is an Adapter ?
● For those who have done Swing UI, an Adapter in Android
is similar to the like of a TableModel in swing.
● It is a bridge or translator between the model (data) and
more complex UI components. It is part of the GUI.
● For Spinner the easiest option for displaying an ArrayList
of object is to use ArrayAdapter
● As in Swing objects which are not Strings will use
toString representation of the object for display.
13. Adding Objects to Spinner
Person p1 = new Person(“john”, 50);
Person p2 = new Person(“mary”, 60);
ArrayList<Person> peopleList = new ArrayList<Person>();
peopleList.add(p1);
peopleList.add(p2);
Spinner sp1 = (Spinner)findViewById(R.id.spinner1);
ArrayAdapter<String> spinnerArrayAdapter =
new ArrayAdapter<String>(this, android.R.layout.simple_spinner_item,
peopleList);
sp1.setAdapter(spinnerArrayAdapter);
14. Fragment Communication
● As we have seen fragments are “self-contained
modular components” (which exist inside an Activity)
● What happens when a Fragment wants to send a
message elsewhere ? (To another Fragment ? To
another Activity ?)
● NB : All communication must be done through the
Fragment’s associated Activity.
15. Fragment communication
● The first step is to allow the Fragment to communicate
“up to” its Activity.
● To do this we define a simple Java interface which
defines what messages (i.e. method calls) the
Fragment can make.
● This interface is usally put inside the Java class of the
Fragment which wants to communicate.
● The content of the interface is entirely up to us.
17. Fragment Communication
interface
public class TopFragment extends Fragment {
public View onCreateView(LayoutInflater inflater, ViewGroup container,
Bundle savedInstanceState)
{
// Inflate the layout for this fragment
return inflater.inflate(R.layout.fragment_bottom, container,
false);
}
}
Presume we already have a basic fragment class
public interface SomethingHappenedInFragment
{
public void sendAMessage(String
message);
}
Put the
communication
interface
within the
Fragment class
18. Activity implements Fragment
interface
● After defining the interface the Activity which the
Fragment needs to communicate with must implement
that interface.
public class MainActivity
extends Activity implements TopFragment.SomethingHappenedInFragment
{
//The rest of the Activity will already be HERE(onCreate() etc)
//..and now the implementation of the SomethingHappenedInFragment
interface
public void sendAMessage(String message)
{
}
Message from
source fragment
arrives here
19. Delivering the
message
● Once the Activity receives the message it needs to find the
Fragment (or Fragments) to deliver the communication to (ie.
Call a method on.
public void sendAMessage(String message)
{
FragmentManager fMgr = getFragmentManager();
//Look up the destination fragment
BottomFragment bottomFrag =
(BottomFragment)fMgr.findFragmentById(R.id.fragment_bottom);
//Call a method on the destination fragment
bottomFrag.someMethodWhichWantsTheMessage(message);
}.
21. The Final Step
● As part of the lifecycle of Activities and Fragments the
Activity “attaches itself” to its Fragments.
● Last week we saw the Fragment lifecycle method
onCreateView which MUST be implemented to get your
Fragment running.
● Before on onCreateView there is an earlier method in the
Fragment lifecycle called onAttach
● onAttach is called by the Activity which conveniently
passes a reference to itself. We store this reference.
22. The Code
public class TopFragment extends Fragment
{
private SomethingHappenedInFragment activity;
@Override
public void onAttach(Activity activity)
{
this.activity = (SomethingHappenedInFragment)activity
}
}
Remember : Our Activity
implements
SomethingHappenedInFragment
so it “is a”
SomethingHappenedInFragment