Are you over 18 and want to see adult content?
More Annotations
A complete backup of nrdcactionfund.org
Are you over 18 and want to see adult content?
A complete backup of learningtoforgive.com
Are you over 18 and want to see adult content?
A complete backup of newhopefellowship.net
Are you over 18 and want to see adult content?
A complete backup of bluegreenowner.com
Are you over 18 and want to see adult content?
A complete backup of coachingforleaders.com
Are you over 18 and want to see adult content?
Favourite Annotations
A complete backup of designrumah.co.id
Are you over 18 and want to see adult content?
A complete backup of theqwietmuse.com
Are you over 18 and want to see adult content?
A complete backup of inkwellclothing.com
Are you over 18 and want to see adult content?
A complete backup of ssbodisha.nic.in
Are you over 18 and want to see adult content?
A complete backup of xn--hckslertest-l8a.de
Are you over 18 and want to see adult content?
A complete backup of imaginesofeveryfandom.tumblr.com
Are you over 18 and want to see adult content?
Text
device.
DOWNLOAD ANDROID STUDIO AND SDK TOOLS Terms and Conditions This is the Android Software Development Kit License Agreement 1. Introduction 1.1 The Android Software Development Kit (referred to in the License Agreement as the "SDK" and specifically including the Android system files, packaged APIs, and Google APIs add-ons) is licensed to you subject to the terms of theLicense Agreement.
GOOGLE PLAY CONSOLE
When you’re ready to launch, the Play Console lets you publish your app and release updates with confidence. Use granular controls and distribution options, and have a complete view of your app’s data during and after release. YouTube. Android Developers. 960Ksubscribers.
INSTALL OEM USB DRIVERS Right-click the name of the device you connected, and then select Update Driver Software. In the Hardware Update wizard, select Browse my computer for driver software and click Next. Click Browse and then locate the USB driver folder. For example, the Google USB Driver is located in android_sdk \extras\google\usb_driver\. KOTLIN COROUTINES ON ANDROID INSTALL ANDROID STUDIO Setting up Android Studio takes just a few clicks. First, be sure you download the latest version of Android Studio.. Windows. To install Android Studio on Windows, proceed as follows: If you downloaded an .exe file (recommended), double-click to launch it.. If you downloaded a .zip file, unpack the ZIP, copy the android-studio folder into your Program Files folder, and then open the android SDK PLATFORM TOOLS RELEASE NOTES Terms and Conditions This is the Android Software Development Kit License Agreement 1. Introduction 1.1 The Android Software Development Kit (referred to in the License Agreement as the "SDK" and specifically including the Android system files, packaged APIs, and Google APIs add-ons) is licensed to you subject to the terms of theLicense Agreement.
GET THE GOOGLE USB DRIVER Terms and Conditions This is the Android Software Development Kit License Agreement 1. Introduction 1.1 The Android Software Development Kit (referred to in the License Agreement as the "SDK" and specifically including the Android system files, packaged APIs, and Google APIs add-ons) is licensed to you subject to the terms of theLicense Agreement.
JETPACK COMPOSE
Jetpack Compose is Android’s modern toolkit for building native UI. It simplifies and accelerates UI development on Android. Quickly bring your app to life with ANDROID DEVELOPERSANDROID STUDIOPLATFORMGOOGLE PLAYJETPACKKOTLINDOCS Android for Developers. Modern tools and resources to help you build experiences that people love, faster and easier, across every Androiddevice.
DOWNLOAD ANDROID STUDIO AND SDK TOOLS Terms and Conditions This is the Android Software Development Kit License Agreement 1. Introduction 1.1 The Android Software Development Kit (referred to in the License Agreement as the "SDK" and specifically including the Android system files, packaged APIs, and Google APIs add-ons) is licensed to you subject to the terms of theLicense Agreement.
GOOGLE PLAY CONSOLE
When you’re ready to launch, the Play Console lets you publish your app and release updates with confidence. Use granular controls and distribution options, and have a complete view of your app’s data during and after release. YouTube. Android Developers. 960Ksubscribers.
INSTALL OEM USB DRIVERS Right-click the name of the device you connected, and then select Update Driver Software. In the Hardware Update wizard, select Browse my computer for driver software and click Next. Click Browse and then locate the USB driver folder. For example, the Google USB Driver is located in android_sdk \extras\google\usb_driver\. KOTLIN COROUTINES ON ANDROID INSTALL ANDROID STUDIO Setting up Android Studio takes just a few clicks. First, be sure you download the latest version of Android Studio.. Windows. To install Android Studio on Windows, proceed as follows: If you downloaded an .exe file (recommended), double-click to launch it.. If you downloaded a .zip file, unpack the ZIP, copy the android-studio folder into your Program Files folder, and then open the android SDK PLATFORM TOOLS RELEASE NOTES Terms and Conditions This is the Android Software Development Kit License Agreement 1. Introduction 1.1 The Android Software Development Kit (referred to in the License Agreement as the "SDK" and specifically including the Android system files, packaged APIs, and Google APIs add-ons) is licensed to you subject to the terms of theLicense Agreement.
GET THE GOOGLE USB DRIVER Terms and Conditions This is the Android Software Development Kit License Agreement 1. Introduction 1.1 The Android Software Development Kit (referred to in the License Agreement as the "SDK" and specifically including the Android system files, packaged APIs, and Google APIs add-ons) is licensed to you subject to the terms of theLicense Agreement.
JETPACK COMPOSE
Jetpack Compose is Android’s modern toolkit for building native UI. It simplifies and accelerates UI development on Android. Quickly bring your app to life withDOCUMENTATION
Poor app performance can ruin the user experience and destroy your app's reputation. If it ever responds slowly, shows choppy animations, freezes, crashes, or consumes a lot of power, your users will notice. To avoid these performance problems, use the Android Profiler to measure your app's memory, CPU, and network usage. Profile your app. ANDROID 12 BETA DEVICES See the following device-maker partner sites for a list of their devices that are eligible for Android 12 Beta. For updates and support, see the resources that each device-maker has linked on their Android 12 Beta site. Note that each partner will handle their own enrollments and support, and provide the Beta updates to you directly.VOLLEY OVERVIEW
Volley is an HTTP library that makes networking for Android apps easier and most importantly, faster. Volley is available on GitHub. Volley offers the following benefits: Automatic scheduling of network requests. Multiple concurrent network connections. Transparent disk and memory response caching with standard HTTP cache coherence. ROOM | ANDROID DEVELOPERS New Features. Auto Closable Databases: Room now has the ability to close databases that are not accessed after a given amount of time. This is an experimental feature and can be enabled by calling RoomDatabase.Builder#setAutoCloseTimeout (). This feature is useful for applications withTEXT IN COMPOSE
Text is a central piece of any UI, and Jetpack Compose makes it easier to display or write text. Compose leverages composition of its building blocks, meaning you don’t need to overwrite properties and methods or extend big classes to have a specific composable design and logic working the way you want. NAVIGATING WITH COMPOSE The Navigation component provides support for Jetpack Compose applications. You can navigate between composables while taking advantage of the Navigation component’s infrastructure and features. Note: If you are not familiar with Compose, review the Jetpack Compose resources before continuing. Setup. To support Compose, use the following dependency in your app module’s APPCOMPAT | ANDROID DEVELOPERS For more information about dependencies, see Add Build Dependencies.. Feedback. Your feedback helps make Jetpack better. Let us know if youdiscover new
VIEW BINDING
View Binding Part of Android Jetpack. View binding is a feature that allows you to more easily write code that interacts with views. Once view binding is enabled in a module, it generates a binding class for each XML layout file present in that module. An instance of a binding class contains direct references to all views that have an ID in the corresponding layout. CARDVIEW | ANDROID DEVELOPERS Declaring dependencies. To add a dependency on CardView, you must add the Google Maven repository to your project. Read Google's Maven repository for more information. Add the dependencies for the artifacts you need in the build.gradle file for your app or module: For more information about dependencies, see Add build dependencies. PARCELABLE IMPLEMENTATION GENERATOR Feedback. The kotlin-parcelize plugin provides a Parcelable implementation generator. When you annotate a class with @Parcelize, a Parcelable implementation is automatically generated, as shown in the following example: import kotlinx.parcelize.Parcelize. @Parcelize. class User(val firstName: String, val lastName: String, val age: Int):Parcelable.
*
Platform Android StudioJetpack
Docs
More
Google Play Kotlin
News
Language English Bahasa Indonesia Español – América Latina Português – Brasil 中文 – 简体 日本語 한국어 Select an optionLanguage* Language
* English
* Bahasa Indonesia
* Español – América Latina * Português – Brasil* 中文 – 简体
* 日本語
* 한국어
Sign in
* Documentation
Overview Guides
Reference
Samples
Design & Quality
More
*
* Platform
* Android Studio
* Google Play
* Jetpack
* Kotlin
* Docs
* Overview
* Guides
* Reference
* Samples
* Design & Quality
* News
*
App Basics
* Introduction
*
Build your first app* Overview
* Create an Android project* Run your app
* Build a simple user interface * Start another activity* App fundamentals
*
App resources
* Overview
* Handle configuration changes*
Localization
* Localize your app
* Test your app with pseudolocales * Unicode and internationalization support * Language and locale resolution * Complex XML resources*
Resource types
* Overview
* Animation
* Color state list
* Drawable
* Layout
* Menu
* String
* Style
* Font
* More types
*
App manifest file
* Overview
*
*
*
*
*
* *
**
*
*
*
*
*
* *
*
*
*
* *
*
*
* *
*
Devices
*
Device compatibility* Overview
* Screen compatibility overview * Support different pixel densities * Support display cutouts * Declare restricted screen support*
Multiple APK support* Overview
* Create multiple APKs for different API levels * Create multiple APKs for different screen sizes * Create multiple APKs for different GL textures * Create multiple APKs with several dimensions * Support different languages and cultures * Support different platform versions * Filters on Google Play*
Tablets, Large screens, and Foldables * Responsive layouts for tablets, large screens, and foldables * Support different screen sizes * Multi-window support * Building apps for foldables*
Wear
* Overview
*
Adding wearable features to notifications* Overview
* Creating a notification * Notification styles * Bridging mode for notifications * Maintaining compatibility*
Creating wearable apps* Overview
* Creating and running a wearable app* Standalone apps
* Creating custom layouts * Keeping your app visible * Authentication in Wear* Voice input
* Packaging and distributing Wear apps * Debugging a Wear app * Capturing Wear UI screenshots * Creating Wear apps for China*
Creating custom UIs
* Overview
* Defining layouts
* Creating lists
* Showing confirmations * Exiting full-screen activities * Using the Wear UI library * Wear navigation and actions* Physical buttons
* Rotary input
* Creating input method editors * Using wrist gestures*
Sending and syncing data* Overview
* Network access and syncing * Accessing the wearable data layer * Syncing data items * Transferring assets * Sending and receiving messages * Handling data layer events * Migrating Wear apps to GoogleApi*
Creating data providers* Overview
* Expose data to complications*
Creating watch faces* Overview
* Designing watch faces * Building a watch face service * Drawing watch faces * Watch face complications * Exposing data to complications * Adding complications to a watch face * Creating interactive watch faces * Providing configuration activities * Addressing common issues * Improve performace with hardware acceleration * Optimizing watch faces * Detecting location* Tiles
* Requesting Permissions* Using the Speaker
*
Android TV
* Overview
*
Build TV Apps
* Overview
* Get started with TV apps * AndroidX TV libraries * Handle TV hardware * Manage TV controllers* Build TV layouts
* On-screen keyboard * Create TV navigation * Best practices for driving engagement on Google TV*
Build TV playback apps* Overview
* Create a catalog browser * Provide a card view * Build a details view * Use Leanback transport controls * Playback controls on TV * Display a Now Playing card* Add a guided step
* Introduce first-time users to your app * Enable background playback*
Help users find content on TV* Overview
*
Recommend TV content* Overview
* Channels on the home screen * Video program attributes * Audio program attributes * Game program attributes*
Watch Next
* Add programs
* Attributes
* Guidelines for app developers * Guidelines for TV providers* Preview videos
* Recommendations in Android N and earlier * Make TV apps searchable * Search within TV Apps* Build TV games
*
Build TV input services* Overview
* Develop a TV input service * Work with channel data * Manage TV user interaction * Support time-shifting * Support content recording* TV Apps checklist
*
TV Accessibility
* Non Native Apps Accessibility Support * Non Native Apps Accessibility Best Practices * TalkBack evaluation examples for TV apps * Android 12 Developer Preview for TV*
Android for Cars
* Overview
*
Build media apps for cars * Build media apps for cars * Add support for Android Auto * Add support for Android Automotive OS * Build messaging apps for Android Auto * Build navigation, parking, and charging apps for Android Auto(Beta)
* Test Android apps for cars * Google Play services * Notifications on Android Automotive OS*
Android Things
* Overview
* Platform differences* Google services
*
Supported hardware
* Overview
* NXP i.MX7D
* Raspberry Pi 3
*
Advanced setup
* Overview
* Manually flash an image* Recover a device
* Connecting to Wi-Fi with adb*
Build apps
*
Create a Things app
* Overview
* Create a project
* Connect the hardware * Interact with peripherals * Integrate peripheral drivers*
Communicate with wireless devices* Bluetooth
* LoWPAN
*
Configure devices
* Settings
* Updates
*
Interact with peripherals* Overview
* GPIO
* PWM
* I2C
* SPI
* UART
* Native PIO
* CLI tool
* Integrate native code*
Build user-space drivers* Overview
* Location
* Input
* Sensors
* LoWPAN
* Samples
*
Manage devices
* Overview
* Create a product
* Configure a product*
Create a build
* Overview
* Manage apps
*
Push an update
* Overview
* Automatic updates
* Monitor analytics
*
Terms
* Console Terms of Service * SDK License Agreement * Android Things Console*
Chrome OS devices
* Overview
* Building apps for Chrome OS * Optimizing Apps for Chrome OS * Preparing your development environment * App Manifest Compatibility for Chromebooks * Chrome OS Device Support for Apps * App Rendering Differences on Chromebooks* Window management
* Input compatibility for Chromebooks * Adapting Games on Chrome OS * Smooth animation on Chrome OS * Test Cases for Android Apps on Chrome OS*
Core topics
*
Activities
* Introduction to activities * The activity lifecycle * Activity state changes * Test your activities * Tasks and back stack * Processes and app lifecycle * Parcelables and bundles*
Fragments
* Overview
* Create a fragment
* Fragment manager
* Fragment transactions * Animate transitions between fragments * Fragment lifecycle * Saving state with fragments * Communicate with fragments * Working with the app bar * Displaying dialogs with DialogFragment * Test your fragments*
Interact with other apps* Overview
* Sending the user to another app * Getting a result from an activity * Allowing other apps to start your activity * Managing package visibility * Configuring package visibility based on use cases*
Handling app links
* Overview
* Enabling links to app content* Verify app links
* Create app links for instant apps* Loaders
* Recents screen
* Restrictions on starting activities from the background*
App shortcuts
* Overview
* Create shortcuts
* Manage shortcuts
* Best practices for shortcuts*
App widgets
* Overview
* Build an app widget * Build an app widget host*
App compatibility
* Overview
* Compatibility framework tools * Restrictions on non-SDK interfaces*
Architecture Components* Overview
* Adding Components to your Project* App Startup
* DataStore
*
View Binding
* Overview
* Migrate from Kotlin synthetics to view binding*
Data Binding Library* Overview
* Get started
* Layouts and binding expressions * Work with observable data objects * Generated binding classes* Binding adapters
* Bind layout views to Architecture Components * Two-way data binding * Handling Lifecycles* LiveData
*
Paging Library
* Overview
* Display paged lists* Load paged data
*
Paging 3
* Overview
* Load and display paged data * Page from network and database * Transform data streams * Migrate to Paging 3* ViewModel
*
WorkManager
* Overview
* Getting Started
*
How-To Guides
* Defining your WorkRequests* Work states
* Managing work
* Observing intermediate Worker progress * Chaining work together * Testing Worker implementation * Integration tests with WorkManager * Debugging WorkManager*
Advanced Concepts
* Configuration and Initialization*
Threading in WorkManager* Overview
* Threading in Worker * Threading in CoroutineWorker * Threading in RxWorker * Threading in ListenableWorker * Support for long-running workers * Migrating from Firebase JobDispatcher * Migrating from GCMNetworkManager* Saving States
* Saved State module for ViewModel * Use Kotlin coroutines with Architecture components* Release notes
* Additional resources*
Navigation component* Overview
* Principles of Navigation* Getting started
* Create destinations * Design for different form factors * Design navigation graphs* Nested graphs
* Global actions
* Navigate to a destination * Conditional navigation * Pass data between destinations * Create a deep link for a destination * Animate transitions between destinations * Update UI components with NavigationUI* Kotlin DSL
* Create swipe views with tabs using ViewPager * Create swipe views with tabs using ViewPager2 * Interact programmatically * Navigate with feature modules* Test navigation
* Handling configuration changes * Add new destination types * Provide custom back navigation * Migrate to the Navigation component*
Intents and intent filters* Overview
* Common intents
*
User interface
* Overview
*
Layouts
* Overview
* Build a responsive UI with ConstraintLayout*
Add motion to your layout with MotionLayout* Overview
* MotionLayout examples*
MotionLayout XML reference* Overview
*
*
*
*
*
*
*
*
*
* Create a list with RecyclerView * Advanced RecyclerView customization * Create a card-based layout * Implementing adaptive UI flows *
Improving layout performance* Overview
* Optimizing layout hierarchies * Re-using layouts with* Linear layout
* Adapter view
* Relative layout
*
Custom view components* Overview
* Creating a custom view class * Implementing custom drawing * Making the view interactive * Optimizing the view*
Look and feel
* Material design
* Styles and themes
* Dark theme
* Adaptive icons
* Add a floating action button * Create shadows and clip views*
Text
* Autosizing TextViews * Downloadable fonts* Fonts in XML
* Emoji compatibility* Magnifier widget
* Spans
* Buttons
* Checkboxes
* Radio buttons
* Toggle buttons
* Spinners
* Pickers
* Tooltips
*
Notifications
* Overview
* Create a notification * Create an expandable notification * Display time-sensitive notifications * Start an activity from a notification * Create a group of notifications * Create and manage notification channels * Modify a notification Badge * Create a custom notification* Conversations
* Bubbles
*
Add the app bar
* Overview
* Set up the app bar * Add and handle actions* Add an up action
* Use action views and action providers*
Control the system UI visibility* Overview
* Dim the system bars * Hide the status bar * Hide the navigation bar * Enable fullscreen mode * Respond to UI visibility changes*
Supporting swipe-to-refresh* Overview
* Adding swipe-to-refresh to your app * Responding to a refresh gesture* Toasts overview
*
Pop-up messages overview* Overview
* Build and display a pop-up message * Add an action to a message* Dialogs
* Menus
*
Settings
* Overview
* Organize your settings * Customize your settings* Use saved values
* Build a hierarchy in code * Handle other form factors * Preference components and attributes*
Search
* Overview
* Creating a search interface * Adding recent query suggestions * Adding custom suggestions * Searchable configuration*
Adding search functionality* Overview
* Setting up the search interface * Storing and searching for data * Remaining backward compatible* Copy and paste
* Drag and drop
* Picture-in-picture Support*
Creating backward-compatible UIs* Overview
* Abstracting the new APIs * Proxying to the new APIs * Creating an implementation with older APIs * Using the version-aware component* Device control
*
Animations & transitions* Overview
* Introduction to animations * Property animation overview * Animate drawable graphics * Reveal or hide a view using animation * Move a view using animation * Move a view using a fling animation * Enlarge a view using a zoom animation * Animate movement using spring physics * Auto animate layout updates * Animate layout changes using a transition * Create a custom transition animation * Start an activity using an animation * Slide between fragments using ViewPager * Slide between fragments using ViewPager2 * Migrate from ViewPager to ViewPager2 * Additional resources*
Images & graphics
* Overview
* Drawables overview * Vector drawables overview* Handling bitmaps
* Selecting colors with the palette API * Reducing image download sizes * Hardware acceleration* OpenGL ES
*
Displaying graphics with OpenGL ES* Overview
* Building an OpenGL ES environment* Defining shapes
* Drawing shapes
* Applying projection and camera views* Adding motion
* Responding to touch events*
Rendering
* Overview
* Reducing overdraw
* Performance and view hierarchies * Analyzing with profile GPU rendering * Enhancing graphics with wide color content*
Audio & video
* Audio & video overview* Media controls
* Supported media formats* Media codecs
*
Media app architecture * Media app architecture overview * Using a media session*
Building an audio app * Audio app overview * Building a media browser service * Building a media browser client * Media session callbacks * Using the media controller test app*
Building a video app * Video app overview * Building a video player activity * Media session callbacks * Responding to media buttons * Handling changes in audio output * Managing audio focus*
The Google Assistant * The Google Assistant and media apps * Media apps on Google Assistant driving mode*
Routing between devices* Routing overview
* MediaRouter overview * MediaRouteProvider overview * Control amplitude with VolumeShaper * MediaPlayer overview * MediaRecorder overview* ExoPlayer
* Sharing audio input* Playback capture
* Frame rate
* Additional Resources for Media*
Services
* Overview
* Foreground services* Bound services
* AIDL overview
*
Background tasks
* Overview
* Background threads * Background optimizations*
Broadcasts
* Overview
* Implicit Broadcast Exceptions*
Manage device awake state* Overview
* Keep the device awake * Schedule repeating alarms*
Permissions
* Overview
* Evaluate whether your app needs permissions * Declare app permissions * Request app permissions * App permissions best practices * Permissions used only in default handlers * Restrict interactions with other apps * Define custom permissions*
App data & files
* Overview
* Storage overview
* Save to app-specific storage*
Save to shared storage* Overview
* Media
* Documents and other files* Datasets
* Manage all files on a storage device * Save key-value data*
Save data in a local database* Overview
* Define data using entities * Access data using DAOs * Define relationships between objects * Write asynchronous DAO queries * Create views into a database * Prepopulate your database * Migrate your database * Test and debug your database * Reference complex data * Migrate from SQLite to Room * Save data using SQLite * Storage use cases and best practices*
Sharing simple data
* Overview
* Sending simple data to other apps * Receiving simple data from other apps*
Sharing files
* Overview
* Setting up file sharing* Sharing a file
* Requesting a shared file * Retrieving file information*
Sharing files with NFC* Overview
* Sending files to another device * Receiving files from another device*
Printing files
* Overview
* Printing photos
* Printing HTML documents * Printing custom documents*
Content providers
* Overview
* Content provider basics * Creating a content provider * Open files using storage access framework * Create a custom document provider * App install location*
User data & identity* Overview
* Add sign-in workflow * Show a biometric authentication dialog*
Autofill framework
* Overview
* Optimize your app for autofill * Build autofill services * Integrate autofill with keyboards* Audit data access
* Get a user-resettable advertising ID * Calendar provider overview*
Contacts provider
* Overview
* Retrieving a list of contacts * Retrieving details for a contact * Modifying contacts using intents * Displaying the quick contact badge* Account transfer
*
Data backup
* Overview
* Back up user data
* Back up key-value pairs * Test backup and restore * Best practices for unique identifiers*
Remember and authenticate users* Overview
* Remember your user * Authenticate to OAuth2 services * Create a custom account type*
User location
* Overview
* Request location permissions * Get the last known location * Change location settings * Request location updates * Access location in the background * Create and monitor geofences * Detect when users start an activity * Optimize location for battery * Migrate to location and context APIs* Add maps
*
Touch & input
* Overview
* Input events
*
Using touch gestures* Overview
* Detect common gestures * Track touch and pointer movements * Animate a scroll gesture * Support navigation gestures * Handle multi-touch gestures* Drag and scale
* Manage touch events in a ViewGroup*
Handling keyboard input* Overview
* Specifying the input method type * Handling input method visibility * Supporting keyboard navigation * Handling keyboard actions*
Supporting game controllers* Overview
* Handling controller actions * Supporting controllers across Android versions * Supporting multiple game controllers*
Input method editors * Creating an input method* Image keyboard
* Spelling checker
*
CameraX
* Overview
* CameraX architecture* Configuration
* Preview
* Analyze images
* Image capture
* Vendor extensions
* Transform output
* Use case rotations* CameraX devices
*
Camera2
* Overview
* Camera capture sessions and requests * Camera enumeration * Use multiple camera streams simultaneously* Multi-Camera API
*
Camera
* Overview
* Taking photos
* Recording videos
* Controlling the camera* Camera API
*
Sensors
* Overview
* Sensors overview
* Motion sensors
* Position sensors
* Environment sensors * Raw GNSS measurements*
Connectivity
* Overview
*
Performing network operations* Overview
* Connect to the network * Manage network usage * Reading network state * Optimize network data usage* Parse XML data
*
Transmit network data using Volley* Overview
* Send a simple request * Set up RequestQueue * Make a standard request * Implement a custom request*
Perform network operations using Cronet* Overview
* Send a simple request * Cronet request lifecycle*
Reference
*
org.chromium.net
* Overview
* CallbackException
*
CronetEngine
* Overview
*
CronetEngine.Builder* Overview
* LibraryLoader
* CronetException
* InlineExecutionProhibitedException* NetworkException
* QuicException
* UploadDataProvider * UploadDataProviders* UploadDataSink
*
UrlRequest
* Overview
* Builder
* Callback
* Status
* StatusListener
*
UrlResponseInfo
* Overview
* HeaderBlock
* Enhance your apps with 5G * Build client-server applications with gRPC*
Transferring data without draining the battery* Overview
* Optimize downloads for efficient network access * Minimize the effect of regular updates * Avoid redundant downloads * Modify patterns based on the connectivity type*
Reduce network battery drain* Overview
* Collecting network traffic data * Analyzing data traffic * Optimizing user-initiated network use * Optimizing app-initiated network use * Optimizing server-initiated network use * Optimizing general network use*
Transfer data using Sync Adapters* Overview
* Create a Stub Authenticator * Create a Stub Content Provider * Create a Sync Adapter * Run a Sync Adapter*
Bluetooth
* Overview
* Bluetooth low energy overview * Use Bluetooth low energy*
NFC
* Overview
* NFC basics
* Advanced NFC
* Host-based card emulation overview*
Telecom
* Overview
* Build a calling app * Prevent caller ID spoofing* Telephony IDs
*
Wi-Fi
* Wi-Fi scanning overview * Wi-Fi peer-to-peer * Wi-Fi aware overview * Wi-Fi location with RTT * Local Only Hotspot * Companion device pairing*
Wi-Fi infrastructure * Wi-Fi infrastructure overview * Wi-Fi suggestion API for internet connectivity * Wi-Fi Network Request API for peer-to-peer connectivity* Passpoint
* Save networks and Passpoint configurations*
USB
* Overview
* Accessory overview* Host overview
* VPN
* Session initiation protocol overview*
Discover and connect* Overview
* Use network service discovery * Create P2P connections with Wi-Fi * Use Wi-Fi P2P for service discovery * Wi-Fi Easy Connect * Open Mobile API reader support*
Renderscript
* Overview
* Advanced RenderScript*
Runtime API reference* Overview
* Numerical types
* Object types
* Conversion functions * Mathematical constants and functions * Vector math functions* Matrix functions
* Quaternion functions * Atomic update functions * Time functions and types * Allocation data access functions * Object characteristics functions * Kernel invocation functions and types * Input/output functions * Debugging functions * Graphics functions and types* Index
*
Web-based content
* Overview
* Building web apps in WebView * Managing WebView objects * Darken web content * User privacy in WebView crash reporting * Migrating to WebView in Android 4.4 * Supporting different screens in web apps * Debugging web apps * Best practices for web apps*
Android App Bundles
* Overview
*
Play Feature Delivery* Overview
* Configure the base module * Configure install-time delivery * Configure on demand delivery * On demand delivery best practices * Configure instant delivery * Configure conditional delivery*
Play Asset Delivery
* Overview
* Build for native or Java* Build for Unity
* Target texture compression formats*
Test your app bundle* Overview
* Locally test module installs*
Google Play
* Google Play Billing*
Google Play Core Library* Overview
* Play Feature Delivery*
Play Asset Delivery
* Overview
* Integrate asset delivery (Java) * Integrate asset delivery (native) * Integrate asset delivery (Unity) * Test asset delivery*
In-app reviews
* Overview
* Integrate using Kotlin or Java * Integrate using native code * Integrate using Unity * Test in-app reviews * Support in-app updates * Locally test module installs* Terms of Service
*
Google Play Instant
* Overview of Google Play Instant*
Get started with instant apps * Create an instant-enabled app bundle * UX best practices for apps*
Get started with instant games* Overview
* Unity plugin
* UX best practices for games * Migrate to Android App Bundles * Implement cloud delivery of assets * Support Google Play Games Services * Instant Play games * Instant Play games checklist * Reduce the size of your instant app or game * Add ads to your instant app or game * Provide multiple entry points*
Integrate with Firebase * Add Google Analytics for Firebase to your instant app * Use Firebase Dynamic Links with instant apps * Technical requirements checklist * Google Play Instant policy*
Resources
* Reference
* Code samples
* SDK release notes
* Instant App Intents*
Support
* Known issues
* StackOverflow
* Google Play Developer API * APK Expansion Files*
Application Licensing* Overview
* Licensing Overview * Setting Up for Licensing * Adding Server-Side Verification * Adding Client-Side Verification * Licensing Reference*
Google Play Install Referrer* Overview
*
Play Install Referrer Library* Overview
* Reference
* Release notes
* Play Install Referrer API* App Actions
*
Slices
* Overview
* Getting Started
* Slice templates
*
Games
*
Develop
* Developer previews * Build your game in Unity * Build your game in Unreal * Create a seamless sign-in experience * Determine sensitive data access needs* Secure your game
* Develop games for all screens * Learn about rendering in game loops*
Optimize
* Tools for optimizing your game * Support 64-bit architectures * Improve your game's performance * Manage memory effectively in games * Detect and diagnose crashes * Identify CPU hot spots*
Implement the Android Game SDK* Overview
* Release notes
*
Achieve proper frame pacing* Overview
*
OpenGL renderers
* Integrate
* Update your build settings * Add frame pacing functions * Verify frame pacing improvement*
Vulkan renderers
* Integrate
* Update your build settings * Add frame pacing functions * Verify frame pacing improvement*
Optimize your frame rate* Overview
*
Custom engine integration* Overview
* Run the demo app
* Enable the API
* Update your build settings * Define annotations, fidelity parameters, and settings * Add frame timing functions * Add loading time recording functions * Validate, package, and publish the APK * Troubleshoot common errors* Advanced usage
*
Unity integration
* Overview
* Enable the API
* Integrate the plugin * Initialize the library and verify operation * Define annotations, fidelity parameters, and quality levels * Add loading time recording functions * Run the monitor app * Review and publish * Troubleshoot common errors*
Incorporate high-performance audio* Overview
* Update your build settings* Use Oboe
* Code samples
* Full guide to Oboe*
Reference
*
Frame Pacing library* Overview
*
Modules
* Swappy common tools* Swappy for OpenGL
* Swappy for OpenGL extras* Swappy for Vulkan
*
Structs
* SwappyStats
* SwappyThreadFunctions* SwappyTracer
* SwappyVkFunctionProvider*
Performance Tuner library*
Custom engine
* Overview
*
Modules
* Tuning Fork cache utilities * Tuning Fork extra utilities * Tuning Fork main interface*
Structs
* TuningFork_CProtobufSerialization* TuningFork_Cache
* TuningFork_LoadingTimeMetadata * TuningFork_MetricLimits * TuningFork_Settings*
Unity
* Overview
*
Classes
* AndroidPerformanceTuner< TFidelity, TAnnotation > * LoadingTimeMetadata* Result< T >
*
Structs
* MetricLimits
*
Namespaces
* Google.Android
* Google.Android.PerformanceTuner* Reduce game size
* Profile graphics
* Debugging native memory use*
Launch and iterate
* Launch your game on Google Play * Create an Android App Bundle in Unity * Add support for instant access * Stay connected with your user base*
Best practices
*
Dependency injection* Overview
* Manual dependency injection * Dependency injection with Hilt * Hilt in multi-module apps * Hilt and Jetpack integrations * Hilt testing guide * Hilt and Dagger annotations cheat sheet*
Dagger
* Dagger basics
* Using Dagger in Android apps * Using Dagger in multi-module apps*
Testing
* Overview
* Fundamentals of testing* Set up project
*
Building effective unit tests* Overview
* Building local unit tests * Building instrumented unit tests*
Automating UI tests
* Overview
* Testing UI for a single app * Testing UI for multiple apps*
Testing app component integrations* Overview
* Testing your service * Testing your content provider * Testing UI performance*
Espresso
* Overview
* Setup instructions* Basics
* Recipes
* Multiprocess
* Accessibility checking* Lists
* Intents
* Web
* Idling resource
* Cheat sheet
* Additional resources* UI Automator
* App Crawler
* JUnit4 Rules
* AndroidJUnitRunner* Release notes
* Additional resources*
Performance
* Overview
*
Android Vitals
* Overview
* Stuck Partial Wake Locks* Excessive Wakeups
* Excessive Background Wi-Fi Scans * Excessive Background Network Usage* ANRs
* Crashes
* Slow Rendering
* Frozen Frames
* Permission Denials* App Startup Time
* App Standby Buckets * Processes and Threads Overview * Better Performance through Threading*
Optimizing for Battery Life* Overview
* Optimizing for Doze and App Standby * Monitoring the Battery Level and Charging State * Determining and Monitoring the Docking State and Type * Power Management Restrictions * Profile Battery Usage * Analyzing Power Use with Battery Historian * Testing power-related issues* Reduce App Size
*
Manage memory
* Overview of Memory Managemement * Memory Allocation among Processes * Manage Your App's Memory*
System tracing
* Overview
* Capture a trace from the command line * Capture a trace on a device* Navigate a report
* Define custom events * Inspect GPU rendering * Designing for Seamlessness * Keeping Your App Responsive* Performance Tips
* SMP Primer for Android * Verifying App Behavior on the Android Runtime (ART)*
Accessibility
* Overview
*
Build and test apps for accessibility * Make apps more accessible * Principles for improving app accessibility * Test your app's accessibility*
Advanced topics
* Make custom views more accessible * Create your own accessibility service * Additional resources*
Privacy
* Privacy best practices*
Security
* App security best practices* Security tips
* Security with data * Security with data across additional Android versions * Security with HTTPS and SSL * Network security configuration * Updating your security provider to protect against SSL exploits*
Protecting against security threats with SafetyNet* Overview
* SafetyNet Attestation API * SafetyNet Safe Browsing API * SafetyNet reCAPTCHA API * SafetyNet Verify Apps API* Cryptography
* Android Keystore System * Verifying hardware-backed key pairs with key attestation * Android Protected Confirmation * Supporting Direct Boot * Running embedded DEX code * App security improvement program*
Build for Billions
* Overview
* Connectivity
* Device capability
* Data cost
* Battery consumption* UI and content
*
Build for Enterprise* Overview
* Developer guide
* Work profiles
* Set up managed configurations*
App feedback
* Send app feedback to EMMs* Test app feedback
* Work contacts
* Device management policies*
Device management
* Overview
* Build a device policy controller*
Dedicated devices
* Overview
* Lock task mode
* Multiple users
* Cookbook
* Device control
* Networking and telephony* Security
* System updates
* Network activity logging*
Android versions
* Overview
* Android 11
* Android 10
* Android 9
* Android 8.0
* Android 7.0
* Device administration* Table of contents
* Best practices for secure network communication * Choose an HTTP client * Resolve DNS queries * Encapsulate network operations with a repository * Survive configuration changes * Read related guides Android 12 Developer Preview is here! Try it out, and give us yourfeedback !
* Android Developers*
Docs
*
Guides
Rate and review
CONNECT TO THE NETWORK* Table of contents
* Best practices for secure network communication * Choose an HTTP client * Resolve DNS queries * Encapsulate network operations with a repository * Survive configuration changes * Read related guides*
To perform network operations in your application, your manifest must include the following permissions:and
ACCESS_NETWORK_STATE permissions are normal permissions, which means
they're granted at install time and don't need to be requested atruntime .
BEST PRACTICES FOR SECURE NETWORK COMMUNICATION Before you add networking functionality to your app, you need to ensure that data and information within your app stays safe when transmitting it over a network. To do so, follow these networking security best practices: * Minimize the amount of sensitive or personal user data that you transmit over thenetwork.
* Send all network traffic from your app over SSL.
* Consider creating a network security configuration , which lets your app trust custom certificate authorities (CAs) or restrict the set of system CAs that it trusts for secure communication. For more information on how to apply secure networking principles, see networking security tips.
CHOOSE AN HTTP CLIENT Most network-connected apps use HTTP to send and receive data. The Android platform includes the HttpsURLConnection client, which supports TLS, streaming uploads and downloads, configurable timeouts, IPv6, and connection pooling. In this topic, we use the Retrofit HTTP client library, which lets you create an HTTP client declaratively. Retrofit also supports automatic serialization of request bodies and deserialization ofresponse bodies.
RESOLVE DNS QUERIES
Devices that run Android 10 (API level 29) and higher have native support for specialized DNS lookups through both cleartext lookups and DNS-over-TLS mode. The DnsResolver API provides generic, asynchronous resolution, which lets you look up SRV, NAPTR, and other record types. Note that parsing the response is left to the app toperform.
On devices that run Android 9 (API level 28) and lower, the platform DNS resolver supports only A and AAAA records. This lets you look up the IP addresses associated with a name but doesn't support any otherrecord types.
For NDK-based apps, see android_res_nsend.
ENCAPSULATE NETWORK OPERATIONS WITH A REPOSITORY To simplify the process of performing network operations and reduce code duplication in various parts of your app, you can use the repository design pattern. A repository is a class that handles data operations and provides a clean API abstraction over some specificdata or resource.
You can use Retrofit to declare an interface that specifies the HTTP method, URL, arguments, and response type for network operations, as in the following example:KotlinJavaMore
interface UserService {@GET("/users/{id}")
suspend fun getUser(@Path("id") id: String): User}
public interface UserService {@GET("/user/{id}")
Call}
Within a repository class, functions can encapsulate network operations and expose their results. This encapsulation ensures that the components that call the repository don't need to know how the data is stored. Any future changes to how the data is stored are isolated to the repository class as well.KotlinJavaMore
class UserRepository constructor( private val userService: UserService) {
suspend fun getUserById(id: String): User { return userService.getUser(id)}
}
class UserRepository { private UserService userService; public UserRepository( UserService userService) {
this.userService = userService;}
public Call}
}
To avoid creating an unresponsive UI, don't perform network operations on the main thread. By default, Android requires you to perform network operations on a thread other than the main UI thread; if you don't, a NetworkOnMainThreadExceptionis thrown. In the
UserRepository class shown in the previous code example, the network operation isn't actually triggered. The caller of the UserRepository must implement the threading either using coroutines or using theenqueue() function.
SURVIVE CONFIGURATION CHANGES When a configuration change occurs, such as a screen rotation, your fragment or activity is destroyed and recreated. Any data that isn’t saved in the instance state for your fragment or activity, which should hold only small amounts of data, is lost and you might need to make your network requests again. You can use a ViewModel to ensure that your data survives configuration changes. A ViewModel is a component that's designed to store and manage UI-related data in a lifecycle-conscious way. Using the UserRepository created above, the ViewModel can make the necessary network requests and provide the result to your fragment or activity using LiveData:
KotlinJavaMore
class MainViewModel constructor( savedStateHandle: SavedStateHandle, userRepository: UserRepository ) : ViewModel() { private val userId: String = savedStateHandle ?: throw IllegalArgumentException("Missing user ID") private val _user = MutableLiveDatainit {
viewModelScope.launch {try {
// Calling the repository is safe as it will move execution off // the main thread val user = userRepository.getUserById(userId) _user.value = user } catch (error: Exception) { // show error message to user}
}
}
}
class MainViewModel extends ViewModel { private final MutableLiveData) {
String userId = savedStateHandle.get("uid"); Call@Override
public void onResponse(Call}
}
@Override
public void onFailure(Call}
});
}
}
READ RELATED GUIDES
To learn more about this topic, see the following related guides: * Optimize battery life * Transfer data without draining the battery* Web apps
* Application fundamentals * Guide to app architecture Next Manage network usage arrow_forwardRate and review
Content and code samples on this page are subject to the licenses described in the Content License . Java is a registered trademark of Oracle and/or its affiliates. Last updated 2021-02-24 UTC.* YouTube
Check out Android Developers on YouTube*
MORE ANDROID
* Android
* Enterprise
* Security
* Source
*
SUPPORT
* Report platform bug * Report documentation bug * Google Play support * Join research studies*
DOCUMENTATION
* Developer guides
* Design guides
* API reference
* Samples
* Android Studio
* Android
* Chrome
* Firebase
* Google Cloud Platform* All products
* Privacy
* License
* Brand guidelines
* Get news and tips by email Subscribe Language English Bahasa Indonesia Español – América Latina Português – Brasil 中文 – 简体 日本語 한국어 Select an optionLanguage* Language
* English
* Bahasa Indonesia
* Español – América Latina * Português – Brasil* 中文 – 简体
* 日本語
* 한국어
Details
Copyright © 2024 ArchiveBay.com. All rights reserved. Terms of Use | Privacy Policy | DMCA | 2021 | Feedback | Advertising | RSS 2.0