100 Key Mobile Development Study Points | Generated by AI
To help you prepare for the Mobile Application Development Technology (Course Code: 14567) exam, I have organized 100 essential knowledge points based on the syllabus. These are divided into logical modules to match the structure of the national self-study examination.
Question: Can you provide 100 key knowledge points for the China National Higher Education Self-Study Examination course “Mobile Application Development Technology” (14567)?
Answer:
Module 1: Introduction & Environment (1-10)
- Definition of Mobile Development: The process of creating software for handheld devices.
- Native Apps: Apps built specifically for one platform (e.g., Java/Kotlin for Android).
- Web Apps: Mobile-optimized websites running in a browser.
- Hybrid Apps: Web apps wrapped in a native container (e.g., Cordova).
- Cross-Platform Frameworks: Tools like Flutter or React Native that use one codebase for multiple OSs.
- Android OS Architecture: Comprised of the Linux Kernel, Hardware Abstraction Layer (HAL), Native Libraries/Android Runtime, Java API Framework, and System Apps.
- ART vs. Dalvik: ART (Android Runtime) uses ahead-of-time (AOT) compilation for better performance.
- JDK (Java Development Kit): Required to compile Java-based Android apps.
- Android Studio: The official Integrated Development Environment (IDE).
- ADB (Android Debug Bridge): A command-line tool used to communicate with an emulator or device.
Module 2: Android Core Components (11-25)
- Activity: Represents a single screen with a user interface.
- Service: Runs in the background to perform long-running operations (no UI).
- Broadcast Receiver: Responds to system-wide broadcast announcements.
- Content Provider: Manages access to a central repository of data.
- Intent: An asynchronous message used to request an action from another component.
- Explicit Intent: Specifies the exact component to start by name.
- Implicit Intent: Declares a general action to perform, letting the system find a match.
- Activity Lifecycle: States include onCreate, onStart, onResume, onPause, onStop, onRestart, and onDestroy.
- Fragment: A modular portion of an Activity’s user interface.
- Fragment Lifecycle: Includes specific callbacks like onAttach and onCreateView.
- Context: An interface to global information about an application environment.
- The Manifest File (AndroidManifest.xml): Essential file describing app components, permissions, and hardware requirements.
- R.java: An auto-generated file that acts as an index to all resources in the project.
- Resources Folder (res/): Contains layouts (layout/), strings (values/), and images (drawable/).
- Task Backstack: The “Last In, First Out” (LIFO) stack of Activities.
Module 3: UI Design & Layouts (26-45)
- View: The basic building block for UI components (widgets).
- ViewGroup: An invisible container that holds other Views (layouts).
- LinearLayout: Aligns children horizontally or vertically.
- RelativeLayout: Positions views relative to each other or the parent.
- ConstraintLayout: Allows complex layouts without nesting; uses constraints for positioning.
- FrameLayout: Designed to block out an area on the screen to display a single item.
- TableLayout: Arranges elements into rows and columns.
- Match_parent: View expands to match the size of its parent.
- Wrap_content: View expands only as much as needed to contain its content.
- dp (Density-independent Pixels): Used for layout dimensions to ensure screen density independence.
- sp (Scale-independent Pixels): Used for font sizes (respects user settings).
- TextView: Displays text to the user.
- EditText: A text field for user input.
- Button: Triggers an action when clicked.
- ImageView: Displays image resources.
- CheckBox/RadioButton: For selecting options from a list.
- ListView: Displays a vertically scrollable list of items (older).
- RecyclerView: A more advanced and flexible version of ListView for large data sets.
- Adapter: Bridges the UI component and the data source.
- Event Listeners: Interfaces like
OnClickListenerto handle user interactions.
Module 4: Data Storage (46-60)
- SharedPreferences: Stores small amounts of primitive data in key-value pairs.
- Internal Storage: Private data stored on the device’s file system.
- External Storage: Shared files (SD card or public folders).
- SQLite Database: A lightweight, relational database for structured data.
- SQLiteOpenHelper: A helper class to manage database creation and version management.
- CRUD Operations: Create, Read, Update, Delete.
- Cursor: An object providing read-write access to the result set returned by a database query.
- Room Persistence Library: An abstraction layer over SQLite for easier database access.
- Content URIs: Strings used by Content Providers to identify data.
- Asset Manager: Used to access raw files bundled with the app (assets/ folder).
- JSON (JavaScript Object Notation): Common format for data exchange.
- XML Parsing: Interpreting data in XML format.
- GSON/Jackson: Libraries used to convert Java objects to/from JSON.
- SQL Injection: A security risk where malicious code is inserted into queries.
- Permissions: Declared in the Manifest to access sensitive data (e.g., READ_CONTACTS).
Module 5: Networking & Services (61-75)
- HTTP/HTTPS: Protocols used for web communication.
- Retrofit: A popular type-safe HTTP client for Android.
- Volley: A networking library designed to make networking for Android apps easier and faster.
- RESTful API: An architectural style for networked applications.
- AsyncTask: (Deprecated but often tested) Class for performing background operations and publishing results on the UI thread.
- Main Thread (UI Thread): Where all UI operations must occur.
- NetworkOnMainThreadException: Occurs when network operations are attempted on the UI thread.
- Handler/Looper: Used for communication between threads.
- WorkManager: Recommended for persistent background work.
- Broadcast Intents: Sent by the system (e.g., “Battery Low”) or apps.
- Sticky Broadcast: A broadcast that stays around after it is finished (deprecated for security).
- NotificationManager: System service to manage status bar notifications.
- PendingIntent: A token you give to a foreign application which allows it to use your application’s permissions to execute a predefined piece of code.
- Foreground Service: A service the user is actively aware of (shows a notification).
- Bound Service: A service that allows other components to bind to it and interact with it.
Module 6: Multimedia & Sensors (76-85)
- MediaPlayer: Used to play audio and video files.
- SurfaceView: Used for drawing graphics or playing video outside the UI thread.
- Camera API / CameraX: Tools for capturing photos and videos.
- SensorManager: System service to access device sensors.
- Accelerometer: Measures the acceleration force applied to the device.
- Gyroscope: Measures the rate of rotation around the device’s axes.
- GPS (Global Positioning System): Used for location tracking.
- LocationManager: Provides access to system location services.
- Geocoding: Converting an address into geographic coordinates.
- Runtime Permissions: Permissions requested while the app is running (Android 6.0+).
Module 7: Advanced Concepts & Optimization (86-100)
- Material Design: Google’s design language for consistent UI/UX.
- WebView: A View that displays web pages within an app.
- ProGuard/R8: Tools for shrinking, optimizing, and obfuscating code.
- Memory Leak: Occurs when an object is no longer used but still referenced, preventing garbage collection.
- ANR (Application Not Responding): Dialog shown when the UI thread is blocked for too long (usually 5 seconds).
- Unit Testing: Testing individual components (JUnit).
- Instrumented Testing: Testing UI and components on a real device/emulator (Espresso).
- Gradle: The build automation system used by Android Studio.
- APK (Android Package): The file format used to distribute and install apps.
- App Bundle (.aab): Modern publishing format that optimizes APK generation for different devices.
- Signing an App: Required for publishing to ensure the author’s identity.
- MVC/MVP/MVVM: Architectural patterns for organizing code logic and UI.
- Jetpack: A suite of libraries to help developers follow best practices.
- Version Control (Git): Managing changes to the source code.
- Deployment: The process of submitting an app to a store like Google Play or Huawei AppGallery.
References:
Would you like me to explain any of these specific points in more detail or provide a sample practice exam based on these topics?