This document provides information about an Android development community and lessons on activities and fragments. It summarizes the key topics covered in an online Android course, including activity and fragment lifecycles, saving persistent data, and communicating between fragments. It also introduces mentors from the community and examples of how to create activities and fragments and handle configuration changes and backgrounding.

1. Campus-Guest
Techiteasy

2. Yarkoni
IronSource
Android Academy
Women Techmakers

3. ~ 2000 members Largest Android Active Community

4. What Do We Do?
●Android Fundamentals
●Android UI / UX
●Community Hackathon
●Android Performance
●Mentors Program

5. Online Lessons
Important:
Watch online lesson
before the meetup!
- Our course:
“Developing Android
Apps”
goo.gl/u1pxZv
- Optional: Nano Degree
- Optional: “Android Basics” courses

7. The Course Plan
- Online lesson @ home
- Lecture @ Campus
- Hands-on @ Campus
- Questions @ Facebook

8. Yarkoni
Android Leader
Ironsource
Android Academy Staff
Yonatan Levin
Google Developer Expert &
Android @ Gett
Britt Barak
Android Leader
Figure8
Yossi Segev
Android Developer
Crave

9. Mentors program

10. Community Mentors
Limor Mekaiten

11. Lecture #4: Activities,
Fragments & Lifecycles
Knowing where you are is important

12. What’s For Today?
● Activity
● Fragment
● Persisting data
● External libraries

13. Reminder - Listeners / callbacks
In computer programming, a callback is a piece of executable code
that is passed as an argument to other code, which is expected to
call back (execute) the argument at some convenient time.
Function a
(listener)
Function a
(listener)
Time
Function a
(listener)
Function a
(listener)
Trigger

14. Example - callback interface

15. Example - CREATE & use callback interface

16. Activity

18. Activity - Creation
Java file.
AndroidManifest.xml declaration.

19. Android Studio - Quick tip

20. Entry Point Java Program?

21. Entry Point Java Program?
public static void main(String[] args)

22. Entry Point Android?

23. Entry Point Android?
“Activity Lifecycle”

24. Do not try this at home
(It won’t work)

25. A way to think of the callbacks

26. Activity Lifecycle
Lifecycle is a sequence of setup and teardown callbacks.
Application lifecycle != Thread lifecycle != activity lifecycle.
User and System determine lifecycle.

27. Activity Lifecycle
An application normally has several activities.
When a new activity starts the old one goes into the stack (LIFO).
3 States:
Resumed - foreground has user focus
Paused - partially visible (in memory)
Stopped - not visible (in memory but can be killed) Activity a
Activity b
Activity c

28. If BACK button pops from the Stack
What does the HOME button do?

29. If BACK button pops from the Stack
What does the HOME button do?
onUserLeaveHint()

30. Activity lifecycle - callbacks
onCreate
onResume
onStart
onPause
onStop
onDestory

31. Activity life cycle
Determined by the user and the system.

32. Activity Lifecycle - Corresponding Methods
Entire lifetime.
Visible lifetime.
Foreground lifetime.

33. What to do in every state
onCreate & onDestroy
will be called at most once.
onPause & onResume
can be called a lot.
Foreground
Visible
Background
onPause()
onStop()
onResume()
onStart()

34. Activity - onCreate()
When: on first creation of activity.
What: inflate view, find references, bind data, initialize one timers.
Also has bundle with previous frozen state.

35. Activity - onStart()
●When: the activity is becoming visible to the user.
●What: specific stuff which happens every time.
●Called every time.

36. Activity - onResume()
●When: User interaction.
●What: resume drawing start animations add listeners.
●Top of the activity stack.
●Always followed by onPause().

37. Activity - onPause()
●When: resuming a previous activity
●What: commit unsaved changes to persistent data, stop intensive
CPU actions but keep drawing, remove listeners.
●Promised by the system.

38. Activity - onStop()
● When: Activity is no longer visible either from starting a new one
or destroying the current one.
●What: stop drawing and animations.
●onRestart() may be triggered after onStop().

39. Activity - onDestroy()
● When: final call before dying.
●What: Nothing important.
●Not promised.
●Can be called due to explicit or implicit destruction. isFinishing()
allows us to distinguish.

40. Example - App Starts for the First Time

41. Example 2- Phone Call

42. Example 3 - ?

43. Example 3 - Configuration Change (rotate)

44. Activity - Life and death
●When is activity “killable”?
○ onStop
○ OnDestroy
●Where do we save the data?
○ onPause
●Calling finish() goes directly to onDestroy()

45. Activity - Rotation
● A.K.A configuration change.
●Destroyed and re-created.
○ re-retrieve all resources, drawables, layouts and strings.
●Requires declaration in manifest per activity and @Override
onConfigurationChange() method.

46. AndroidManifest.xml + SecondActivity.java

47. Developer Responsibilities
● Be aware of lifecycle.
● Unregister/Stop actions before death.
● Save state before death.

48. Developer Responsibilities Example
Does not crash if the user receives a phone call or switches to
another app.
Does not consume valuable system resources when the user is not
actively using your app.
Does not lose user’s progress when he leaves and returns to the
app.
Does not crash or lose user’s progress on orientation change.

49. Saving Persistent State

50. Saving Persistent Data
Shared document-like data (SQL / Contentprovider).
User preference (savedInstance / SharedPrefs).

51. Activity - Data Models
● Primitives using <Key, Value> pairs.
●@Serializable/@Parcelable.

52. Saving Persistent Data
SharedPrefernces
Example

53. Get & Set SharedPrefs

54. Saving Persistent Data
SavedInstance Primitive
Example

55. On the way out

56. On the way in

58. Saving Persistent Data
SavedInstance Parcelable
Example

59. Dedicated pojo

60. Dedicated pojo

61. Parcelable - How to use
MainActivity.java

62. Parcelable - How to use
SecondActivity.java

63. Shortcut!

64. SavedInstanceState - IcePick
Icepick - https://github.com/frankiesardo/icepick
Annotation based.

66. Everything has a Price

67. SavedInstanceState - TEST it!
Don’t keep activities.

68. Fragments

69. Represents an operation or interface within
an Activity

70. Fragments
●Started with android API 11 (Honeycomb).
●Sophisticated UI on larger screens.
●Modularize code.
○ Receives its own input.
○ Can be added or removed while the activity is running.
○ Has its own lifecycle.

71. Fragments - Better UI

72. Fragments - Code Recipe
Must have empty constructor.
Use factory design pattern.
onCreate receives arguments passed.
onCreateView return inflated View.

73. Fragment - onCreate()
When: creating the fragment.
What: Initialize essential component of the fragment that you want
to retain when the fragment is paused or stopped, then resumed.

74. Fragment - onCreateView()
●When: drawing occurs for the first time.
●What: To draw a UI for a fragment, you must return a view from
this method that is the root of your fragment’s layout. You can
return null if the fragment does not provide a UI.

75. Fragment - Lifecycle

76. Fragment - Activity Lifecycle relation
●Important - Activity drives the fragment.

77. Fragments
1st way

78. Fragment creation using Factory

79. Fragment creation using Factory

81. Fragments
2nd way

82. Fragments - FragmentManager
Interaction with fragments is done via FragmentManager.
Has its own back stack for transactions - addToBackStack().

84. Fragments - Backstack
●When a user presses back
In an activity any Transaction
on the BackStack are popped
fff before the activity
finishes itself. Fragment a
Fragment b
Fragment c
Fragment
BackStack
Activity B
Activity A
ActivitiesBackStack

85. Fragments
Different UI for Tablets

88. Fragments - Support Multiple Screens
Smallest width.

89. Fragment - Passing data between fragments
●Should always occur via the joint parent activity.

90. Fragments - Passing data between fragments
●Should always occur via the joint parent activity.
●Define an interface in the fragment class and implement it within
the activity.
●The Fragment captures the interface implementation in
onAttach().
●From there you can call interface methods to communicate to the
activity.

91. Activity implements Fragment’s interface
Fragments - Passing data between fragments
Fragment A
has reference
to Activity
Fragment B
has reference
to Activity

92. Fragment Callback to activity

93. Activity Implementation

94. Activity

95. Shortcut!

96. What is the connection?

97. Fragments - Passing data between fragments
Otto Library
Event bus.
Decouples code.
Communication.

98. Otto - Recipe
Create a singleton holding an instance of Bus class.
Register to bus.
Create a method to receive and annotate with @Subscribe.
Publish message to subscribers.
Unregister to bus (onStop).

99. Singleton making Bus accessible to all

100. Activity - Register to bus

101. Method to Receive the message

102. Publish message to Subscribers

103. DO NOT forget to unregister

104. Homework:
1.Go over Activity & Fragments.
2.Watch Lesson #5 of Udacity.
3.Mid stage Sunshine development.

105. 34th floor

107. Drive home safe
See you next Sunday!