The post Android Navigation Drawer Tutorial (Modern Implementation Guide) appeared first on javatechig.com.
]]>In modern Android development, navigation drawers are implemented using DrawerLayout along with Material Design components, ensuring a consistent and user-friendly experience across devices.
This guide explains when to use a navigation drawer, design best practices, and how to implement it using updated Android APIs.
When Should You Use a Navigation Drawer?
A navigation drawer is ideal when:
- Your app has multiple top-level destinations
- Navigation options cannot fit comfortably in a bottom navigation bar
- Sections are conceptually equal in importance
Do NOT use a navigation drawer when:
- Your app has only 2–3 destinations
- Navigation is simple and flat
- Bottom navigation or tabs are sufficient
Always follow Material Design navigation guidelines when choosing a drawer.
Navigation Drawer Architecture (Modern Approach)
A standard navigation drawer implementation includes:
- DrawerLayout as the root layout
- NavigationView for drawer menu items
- FragmentContainerView for main content
- Toolbar integrated with drawer toggle
Step 1: Add Required Dependencies
Make sure you’re using AndroidX and Material Components:
implementation "androidx.drawerlayout:drawerlayout:1.2.0"
implementation "com.google.android.material:material:1.11.0"Step 2: Create Drawer Layout (XML)
Key Design Notes
- Drawer width should not exceed 320dp
- Drawer overlays content instead of replacing it
- NavigationView handles menu styling automatically
Step 3: Setup Drawer in Activity
public class MainActivity extends AppCompatActivity {
private DrawerLayout drawerLayout;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
Toolbar toolbar = findViewById(R.id.toolbar);
setSupportActionBar(toolbar);
drawerLayout = findViewById(R.id.drawer_layout);
ActionBarDrawerToggle toggle = new ActionBarDrawerToggle(
this,
drawerLayout,
toolbar,
R.string.drawer_open,
R.string.drawer_close
);
drawerLayout.addDrawerListener(toggle);
toggle.syncState();
}
}
Step 4: Handle Navigation Item Clicks
NavigationView navigationView = findViewById(R.id.navigation_view);
navigationView.setNavigationItemSelectedListener(item -> {
switch (item.getItemId()) {
case R.id.nav_home:
loadFragment(new HomeFragment());
break;
case R.id.nav_profile:
loadFragment(new ProfileFragment());
break;
}
drawerLayout.closeDrawers();
return true;
});
Step 5: Load Fragments Dynamically
private void loadFragment(Fragment fragment) {
getSupportFragmentManager()
.beginTransaction()
.replace(R.id.content_frame, fragment)
.commit();
}
Best Practices (Senior-Level Advice)
- Use NavigationView, not ListView
- Avoid deep nesting in drawer menus
- Keep drawer items stable and predictable
- Highlight selected item
- Use fragments, not activities, for content switching
Common Mistakes to Avoid
- Using ListView instead of NavigationView
- Overloading drawer with too many options
- Not syncing drawer toggle state
- Mixing drawer with bottom navigation unnecessarily
Final Thoughts
The navigation drawer remains a powerful navigation pattern when used correctly. By following Material Design principles and using modern Android APIs, you can build scalable, user-friendly navigation for complex applications.
This updated approach ensures your app remains maintainable, modern, and aligned with current Android development standards.
The post Android Navigation Drawer Tutorial (Modern Implementation Guide) appeared first on javatechig.com.
]]>The post Android Frame Animation Example – Drawable Animation Guide appeared first on javatechig.com.
]]>This updated guide on javatechig.com explains how to create frame animations using XML and Kotlin/Java, with best practices for performance and lifecycle-safe control.
What Is Frame Animation in Android?
Frame animation (also called drawable animation) displays a sequence of drawable images in rapid succession.
Key characteristics:
- Uses a list of drawable resources
- Defined via XML or code
- Best for sprite-style sequences
- Not ideal for complex motion transitions
For more advanced motion effects, prefer property animations (ObjectAnimator, MotionLayout).
How Frame Animation Works
Android frame animation uses an AnimationDrawable object. You define an animation list in XML with your frames, durations, and sequence order. When played back, Android renders the frames one after another.
Step 1 – Create Frame Animation XML List
Create an XML file in res/drawable (e.g., frame_anim.xml):
Attribute explanation:
android:oneshot="false"— animation loops continuouslyandroid:duration— milliseconds per frame
Step 2 – Add Frame Animation to Layout
In your layout XML:
This binds your animation list to an ImageView.
Step 3 – Control Animation in Code
Kotlin Example
val imageView = findViewById(R.id.frameImageView)
val frameAnimation = imageView.drawable as AnimationDrawable
frameAnimation.start() // start animation
frameAnimation.stop() // stop animation
Java Example
ImageView imageView = findViewById(R.id.frameImageView);
AnimationDrawable frameAnimation = (AnimationDrawable) imageView.getDrawable();
frameAnimation.start(); // start animation
frameAnimation.stop(); // stop animation
Optimize Frame Animation
Use Fewer Frames
Too many frames increase memory consumption and slow devices.
Use Appropriate Sizes
Match frame sizes to display size to avoid scaling overhead.
Decode Efficiently
Use BitmapFactory.Options when loading large frames.
Lifecycle-Aware Control
Start and stop animations based on lifecycle to conserve resources:
Kotlin
override fun onStart() {
super.onStart()
frameAnimation.start()
}
override fun onStop() {
frameAnimation.stop()
super.onStop()
}
Java
@Override
protected void onStart() {
super.onStart();
frameAnimation.start();
}
@Override
protected void onStop() {
frameAnimation.stop();
super.onStop();
}
Frame vs Property Animation
| Feature | Frame Animation | Property Animation |
|---|---|---|
| Based on | Drawable frames | Object property changes |
| Use case | Sprite sequences | Smooth transitions |
| Flexibility | Limited | High |
| Performance | Lower for many frames | Optimized |
Use frame animation for simple sprite effects; prefer property animations for complex UI motion.
Common Issues & Fixes
No Animation Visible
Cause: android:oneshot="true"
Fix: Set false for looping or re-start manually.
Large Memory Footprint
Cause: Many large frames
Fix: Reduce frame count, scale bitmaps
Animation Stops Abruptly
Cause: Lifecycle interruptions
Fix: Control start/stop in lifecycle methods
Best Practices (2026 Updated)
- Only use frame animation for small sprite sequences
- Use vector animations (AnimatedVectorDrawable) for UI transitions
- Reuse frames where possible
- Profile memory when using many images
- Prefer property animations for responsive UIs
The post Android Frame Animation Example – Drawable Animation Guide appeared first on javatechig.com.
]]>The post Android TextToSpeech Example with Kotlin & Java appeared first on javatechig.com.
]]>This updated guide on javatechig.com covers TextToSpeech implementation using modern APIs, proper language handling, and lifecycle management for robust integration.
What Is TextToSpeech in Android?
Android’s TextToSpeech API provides a system service that turns text into spoken words by using language engines available on the device.
Key benefits:
- Accessibility support
- Spoken feedback
- Hands-free user experiences
This API works with both Kotlin and Java projects.
Adding TextToSpeech in Android Project
TextToSpeech is part of the Android framework; no extra Gradle dependency is required.
Ensure minimum SDK is set appropriately:
minSdkVersion 21+
Higher SDK levels improve language support and engine stability.
Initializing TextToSpeech
Kotlin Initialization
lateinit var tts: TextToSpeech
tts = TextToSpeech(this) { status ->
if (status == TextToSpeech.SUCCESS) {
tts.language = Locale.US
}
}
Java Initialization
TextToSpeech tts = new TextToSpeech(this, status -> {
if (status == TextToSpeech.SUCCESS) {
tts.setLanguage(Locale.US);
}
});
In both cases, onInit callback confirms when the engine is ready.
Speaking Text Programmatically
Kotlin Example
fun speak(text: String) {
tts.speak(text, TextToSpeech.QUEUE_FLUSH, null, "tts1")
}
Java Example
tts.speak("Hello from TTS", TextToSpeech.QUEUE_FLUSH, null, "tts1");
Use unique utterance IDs to track speech callbacks if needed.
Handling Language and Locale Support
Always verify that the selected language is supported:
val result = tts.setLanguage(Locale.UK)
if (result == TextToSpeech.LANG_MISSING_DATA || result == TextToSpeech.LANG_NOT_SUPPORTED) {
Log.e("TTS", "Language not supported")
}
Missing data can be resolved by installing voice packs via device settings.
Stopping and Releasing Resources
TextToSpeech consumes system resources. Always release it when no longer needed.
Kotlin
override fun onDestroy() {
super.onDestroy()
tts.stop()
tts.shutdown()
}
Java
@Override
protected void onDestroy() {
super.onDestroy();
tts.stop();
tts.shutdown();
}
Proper shutdown prevents memory leaks and runtime issues.
Advanced Features
Utterance Progress Listener
Track speech events:
tts.setOnUtteranceProgressListener(object : UtteranceProgressListener() {
override fun onStart(utteranceId: String) {}
override fun onDone(utteranceId: String) {}
override fun onError(utteranceId: String) {}
})
Useful for sequencing spoken text or UI actions.
Common Errors & Fixes
1. No Sound Output
Cause: TTS engine not initialized
Fix: Confirm SUCCESS in init callback
2. Unsupported Language Error
Cause: Missing voice data
Fix: Prompt user to install language data
3. Multiple Overlapping Speech Requests
Cause: QUEUE_ADD misuse
Fix: Use QUEUE_FLUSH for immediate speech
Best Practices (2026 Updated)
- Test on real devices with different TTS engines
- Provide user preferences for speech rate and pitch
- Avoid long text passages without user consent
- Release TTS in
onDestroy()to free resources - Leverage
UtteranceProgressListenerfor advanced flows
The post Android TextToSpeech Example with Kotlin & Java appeared first on javatechig.com.
]]>The post Add Zoom Controls to Android MapView – Google Maps SDK Guide appeared first on javatechig.com.
]]>This updated guide on javatechig.com shows how to include zoom controls in your map screen using current best practices from Google and the Maps SDK for Android.
What Are Zoom Controls in MapView?
Zoom controls are UI elements consisting of “+” (zoom in) and “–” (zoom out) buttons that let users adjust the map’s zoom level with a tap. These built‑in controls are hidden by default and can be enabled programmatically.
In addition to zoom controls, the Maps SDK supports other UI controls such as:
- Compass
- Map toolbar
- Gesture settings (pinch, pan, rotate)
Enable Zoom Controls in XML (Recommended)
When using a SupportMapFragment or MapView in your layout, you can enable zoom controls directly via XML attributes:
Add the namespace:
xmlns:map="http://schemas.android.com/apk/res-auto"
This automatically turns on zoom buttons without additional code.
Enable Zoom Controls Programmatically
If you prefer to control the map settings in code, you can enable zoom controls after the map initializes.
Kotlin
supportFragmentManager
.findFragmentById(R.id.map)!!
.getMapAsync { googleMap ->
val uiSettings = googleMap.uiSettings
uiSettings.isZoomControlsEnabled = true
}
Java
SupportMapFragment mapFragment = (SupportMapFragment)
getSupportFragmentManager().findFragmentById(R.id.map);
mapFragment.getMapAsync(new OnMapReadyCallback() {
@Override
public void onMapReady(GoogleMap googleMap) {
googleMap.getUiSettings().setZoomControlsEnabled(true);
}
});
This shows zoom controls anchored on the map’s UI by default.
Adjusting Zoom Controls Position
The SDK places zoom controls in the bottom‑right corner by default, but you can offset UI elements using padding:
googleMap.setPadding(left, top, right, bottom)
This helps avoid overlapping with other UI elements (e.g., buttons or toolbars).
Enable Zoom Gestures & Other Map Interaction
Zoom controls work alongside gesture zoom (pinch and double‑tap). If needed, you can enable or disable gestures:
Kotlin
googleMap.uiSettings.isZoomGesturesEnabled = true
This ensures users can use both button controls and touch gestures.
Best Practices
Use Built‑in UI Settings
Avoid deprecated classes such as ZoomButtonsController (which was deprecated in API 26) for maps — prefer the Maps SDK’s UiSettings.
Respect Map Padding
Set padding to avoid UI overlap with action bars or other views.
Test Across Screen Sizes
Ensure your map UI (buttons, compass, gestures) functions predictably on phones, tablets, and foldables.
Summary
Enabling zoom controls on Android MapView (with the Google Maps SDK) is simple and follows modern Android practices:
- Turn on built‑in zoom buttons via XML
- Enable zoom controls programmatically via
UiSettings - Combine with gesture support for a smooth user experience
This implementation leverages the Maps SDK’s native UI settings and keeps your map interactions consistent and intuitive for users.
The post Add Zoom Controls to Android MapView – Google Maps SDK Guide appeared first on javatechig.com.
]]>The post JSON Feed Reader in Android appeared first on javatechig.com.
]]>This updated guide on javatechig.com explains how to implement a JSON feed reader in Android using robust networking, parsing, and UI handling techniques with both Kotlin and Java.
What Is a JSON Feed Reader?
A JSON feed reader in Android:
- Sends HTTP requests to a server
- Receives JSON responses
- Parses the JSON into usable objects
- Renders data in UI components like RecyclerView
Modern Android applications should use lifecycle-aware networking and asynchronous tasks to ensure smooth performance and responsiveness.
Choosing the Right Networking Library
Shared modern options:
1. Retrofit (Recommended)
- Type-safe HTTP client
- Built-in JSON support
- Works well with coroutines
2. OkHttp
- Low-level HTTP client
- Suited for custom networking
3. Volley
- Good for quick requests
- Less flexible than Retrofit
This guide focuses on Retrofit with Gson because it balances simplicity and power.
Step 1 — Add Dependencies
In build.gradle:
implementation 'com.squareup.retrofit2:retrofit:2.9.0'
implementation 'com.squareup.retrofit2:converter-gson:2.9.0'
Also add:
implementation 'androidx.recyclerview:recyclerview:1.3.1'
Step 2 — Define JSON Data Model
Assuming the JSON feed:
[
{
"title": "First Article",
"description": "Description here",
"imageUrl": "https://example.com/image.jpg"
}
]
Kotlin Data Class
data class FeedItem(
val title: String,
val description: String,
val imageUrl: String
)
Java Model Class
public class FeedItem {
private String title;
private String description;
private String imageUrl;
// getters and setters
}
Step 3 — Create Retrofit API Interface
interface ApiService {
@GET("feed.json")
suspend fun fetchFeed(): List
}
For Java with Callbacks:
public interface ApiService {
@GET("feed.json")
Call> fetchFeed();
}
Step 4 — Initialize Retrofit
Kotlin
val retrofit = Retrofit.Builder()
.baseUrl("https://your-api-domain.com/")
.addConverterFactory(GsonConverterFactory.create())
.build()
val api = retrofit.create(ApiService::class.java)
Java
Retrofit retrofit = new Retrofit.Builder()
.baseUrl("https://your-api-domain.com/")
.addConverterFactory(GsonConverterFactory.create())
.build();
ApiService api = retrofit.create(ApiService.class);
Step 5 — Fetch JSON Feed
Kotlin (Coroutines)
lifecycleScope.launch {
try {
val feed = api.fetchFeed()
adapter.submitList(feed)
} catch (e: Exception) {
Log.e("JSONFeed", "Error: ${e.localizedMessage}")
}
}
Java (Callback)
api.fetchFeed().enqueue(new Callback>() {
@Override
public void onResponse(Call> call, Response> response) {
adapter.setData(response.body());
}
@Override
public void onFailure(Call> call, Throwable t) {
Log.e("JSONFeed", "Error: " + t.getMessage());
}
});
Step 6 — Display Data in RecyclerView
Create an adapter that binds FeedItem objects to a RecyclerView.
Kotlin Adapter Snippet
class FeedAdapter : ListAdapter(DiffCallback()) {
override fun onCreateViewHolder(parent: ViewGroup, viewType: Int): ViewHolder {
val binding = ItemFeedBinding.inflate(LayoutInflater.from(parent.context), parent, false)
return ViewHolder(binding)
}
override fun onBindViewHolder(holder: ViewHolder, position: Int) {
holder.bind(getItem(position))
}
}
Bind data in the view holder with image loaders like Glide or Coil for performance.
Handling Errors & Edge Cases
1. API Failure or No Internet
Show a retry UI and message:
- Display Snackbar or Toast
- Provide retry button
2. Empty Response
Show a placeholder or “No items available”.
3. JSON Parsing Errors
Ensure model matches API structure. Use @SerializedName where necessary.
Best Practices (2026 Updated)
- Use Retrofit + Gson/Moshi
- Use coroutines with LiveData or Flow
- Avoid networking on the main thread
- Cache responses with OkHttp cache
- Use pagination for large feeds
- Secure API calls with HTTPS
Performance Considerations
- Load images with Glide/Coil asynchronously
- Use DiffUtil in RecyclerView adapters
- Avoid heavy UI operations on bind()
The post JSON Feed Reader in Android appeared first on javatechig.com.
]]>The post Different Way to Handle Events in Android appeared first on javatechig.com.
]]>This updated guide explains the different ways to manage events efficiently in Android applications using both Kotlin and Java, aligned with modern Android app architecture.
What Is Event Handling in Android?
Event handling refers to reacting to user interactions such as:
- Clicks and taps
- Long presses
- Touch events
- Gestures (swipe, fling, scale)
- UI component selection events
Android’s event system is built on a well-defined set of listener interfaces and callback methods that ensure responsive and intuitive user experiences.
1. Click Listener
The most common interaction is a button click.
Kotlin Example
button.setOnClickListener {
Toast.makeText(this, "Button clicked!", Toast.LENGTH_SHORT).show()
}
Java Example
button.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
Toast.makeText(MainActivity.this, "Button clicked!", Toast.LENGTH_SHORT).show();
}
});
This is the basic event listener used for most UI actions.
2. Long Press Listener
A long press triggers when the user presses and holds.
Kotlin Example
button.setOnLongClickListener {
Toast.makeText(this, "Long pressed!", Toast.LENGTH_SHORT).show()
true
}
Java Example
button.setOnLongClickListener(new View.OnLongClickListener() {
@Override
public boolean onLongClick(View v) {
Toast.makeText(MainActivity.this, "Long pressed!", Toast.LENGTH_SHORT).show();
return true;
}
});
Returning true indicates that the event is consumed.
3. Touch Listener
Touch events give more control over pointer actions.
Kotlin Example
view.setOnTouchListener { v, event ->
when (event.action) {
MotionEvent.ACTION_DOWN -> { /* Handle down */ }
MotionEvent.ACTION_UP -> { /* Handle up */ }
}
true
}
Java Example
view.setOnTouchListener(new View.OnTouchListener() {
@Override
public boolean onTouch(View v, MotionEvent event) {
switch (event.getAction()) {
case MotionEvent.ACTION_DOWN:
break;
case MotionEvent.ACTION_UP:
break;
}
return true;
}
});
Touch listeners provide granular control for custom interactions.
4. Gesture Detection
To detect gestures efficiently, use GestureDetector.
Kotlin Example
val gestureDetector = GestureDetector(this, object: GestureDetector.SimpleOnGestureListener() {
override fun onFling(e1: MotionEvent?, e2: MotionEvent?, velocityX: Float, velocityY: Float): Boolean {
// handle fling
return true
}
})
view.setOnTouchListener { _, event ->
gestureDetector.onTouchEvent(event)
}
Java Example
final GestureDetector gestureDetector = new GestureDetector(this, new GestureDetector.SimpleOnGestureListener() {
@Override
public boolean onFling(MotionEvent e1, MotionEvent e2, float velocityX, float velocityY) {
return true;
}
});
view.setOnTouchListener((v, event) -> gestureDetector.onTouchEvent(event));
Gesture detectors simplify complex gesture handling.
5. List Item Click Events
In RecyclerView:
Adapter Kotlin Example
holder.itemView.setOnClickListener {
listener.onItemClick(position)
}
Implement listener in the Activity/Fragment:
adapter.setOnItemClickListener { position ->
// Handle click
}
RecyclerView event delegation ensures clear separation of UI logic.
Event Handling Best Practices
To write scalable and maintainable event code:
Use ViewBinding
Avoid findViewById() and leverage ViewBinding for type safety.
Centralize Listeners
Use shared handlers or delegate interactions through interfaces.
Avoid Anonymous Logic
Separate event logic from UI binding for testability.
Respect Lifecycle
Make sure events do not leak memory after Activity/Fragment destruction.
Modern Alternatives
LiveData / Flow with UI Events
Using reactive streams decouples UI and business logic:
buttonClicks
.onEach { /* handle */ }
.launchIn(lifecycleScope)
Jetpack Compose Event Handling
Compose handles events declaratively:
Button(onClick = { /* handle */ }) {
Text("Click Me")
}
Compose replaces traditional XML + listener patterns for modern apps.
Common Mistakes
1. Event Logic in UI Layer Only
This leads to untestable code. Prefer separation with architecture patterns.
2. Using Global Listeners
Avoid setting listeners globally for unrelated UI.
3. Not Handling Edge Cases
Touch events require careful threshold management (swipe vs. click).
The post Different Way to Handle Events in Android appeared first on javatechig.com.
]]>The post How to Generate APK and Install on Android Device appeared first on javatechig.com.
]]>What Is an APK?
An APK (Android Package Kit) is the packaged artifact of your app that includes compiled code, resources, and metadata. Android devices use APKs to install and run applications.
- Development builds (debug)
- Production builds (signed release)
- App bundles (AAB via Play Store)
This guide focuses on APK generation and installation workflows.
Method 1 — Generate Debug APK in Android Studio
Debug APKs are signed automatically by a debug keystore and are suitable for development testing.
Step-by-Step
- Open your project in Android Studio
- Navigate to:
Build → Build Bundles / APKs → Build APKs
- Wait for the build to finish
- Click Locate when the build completes
You’ll find the APK under:
/app/build/outputs/apk/debug/app-debug.apk
Method 2 — Generate Signed Release APK
For publishing or distribution outside Play Store, your app must be signed with your release key.
Step 1 — Create a Release Keystore
In Android Studio:
Build → Generate Signed Bundle / APK
Choose APK and select or create a keystore:
- Keystore path
- Alias name
- Passwords
Step 2 — Choose Build Variant
Select:
- release
- Optional: minifyEnabled (ProGuard/R8)
Step 3 — Finish and Locate
Once finished, locate your release APK:
/app/build/outputs/apk/release/app-release.apk
Method 3 — Command Line (Gradle)
If you prefer terminal workflows:
Debug APK
./gradlew assembleDebug
Release APK
./gradlew assembleRelease
These tasks produce builds under:
app/build/outputs/apk/
This approach is essential for CI/CD pipelines.
Installing APK on a Device
To install APKs on a physical device, follow these steps.
Step 1 — Enable Developer Options
- Open device Settings
- Go to About phone
- Tap Build number 7 times
- Developer options unlocked
Step 2 — Enable USB Debugging
Navigate to:
Settings → Developer options → USB debugging
Toggle on.
Install Using Android Studio
- Connect your device via USB
- Ensure device is detected in the toolbar
- Click Run (
) - The selected APK installs automatically
This method simplifies iterative testing during development.
Install Using ADB Command Line
ADB (Android Debug Bridge) is ideal for scripted installs.
Step 1 — Verify Device
adb devices
Your device should appear in the list.
Step 2 — Install APK
adb install path/to/app-debug.apk
To reinstall and overwrite:
adb install -r path/to/app-debug.apk
ADB installation is often used in CI/CD test scripts.
Best Practices
Use USB 3.0 or ADB Over Wi-Fi
Faster transfers improve productivity.
Signed Release for Distribution
Always sign release builds with your secure keystore.
Test on Multiple Android Versions
Validate compatibility across Android 8, 9, 10, 11, 12, 13 and beyond.
Use App Bundle for Play Store
Google Play now prefers AAB (Android App Bundle) but APKs are still valid for testing.
Troubleshooting Common Issues
Device Not Detecting
- Reconnect USB
- Toggle USB debugging off/on
- Check USB drivers (Windows)
INSTALL_FAILED_OLDER_SDK
Cause: APK minSdkVersion > device SDK
Fix: Build with compatible SDK
INSTALL_PARSE_FAILED_NO_CERTIFICATES
Cause: Unsigned APK
Fix: Use signed build or debug APK
The post How to Generate APK and Install on Android Device appeared first on javatechig.com.
]]>The post Android Toast Example – Show Messages in Android Apps appeared first on javatechig.com.
]]>This updated guide on javatechig.com covers how to show Toast messages using modern Android APIs in both Kotlin and Java — including custom layouts, duration control, positioning, and best practices.
What Is a Toast in Android?
A Toast is a transient message that pops up on the screen for a short duration without blocking user interaction. It’s part of the Android UI framework and requires no extra permission.
Typical use cases:
- Showing success message
- Confirming user actions
- Indicating brief status feedback
Toasts are not suitable for critical alerts — use Snackbars or Dialogs for that.
Basic Toast Implementation
Kotlin Example
Toast.makeText(
this,
"This is a simple Toast message",
Toast.LENGTH_SHORT
).show()
Java Example
Toast.makeText(
MainActivity.this,
"This is a simple Toast message",
Toast.LENGTH_SHORT
).show();
Duration Options
| Constant | Duration |
|---|---|
Toast.LENGTH_SHORT | ~2 seconds |
Toast.LENGTH_LONG | ~3.5 seconds |
Custom Toast Layout
For richer UI, you can create a custom toast layout.
Step 1: Create Custom Layout (toast_layout.xml)
Displaying Custom Toast
Kotlin
val inflater = layoutInflater
val layout = inflater.inflate(R.layout.toast_layout, null)
val toast = Toast(applicationContext)
toast.duration = Toast.LENGTH_LONG
toast.view = layout
toast.show()
Java
LayoutInflater inflater = getLayoutInflater();
View layout = inflater.inflate(R.layout.toast_layout, null);
Toast toast = new Toast(getApplicationContext());
toast.setDuration(Toast.LENGTH_LONG);
toast.setView(layout);
toast.show();
Positioning Toast on Screen
By default, Toast appears near the bottom center. You can adjust the position:
Kotlin
toast.setGravity(Gravity.TOP or Gravity.CENTER_HORIZONTAL, 0, 200)
toast.show()
Java
toast.setGravity(Gravity.TOP | Gravity.CENTER_HORIZONTAL, 0, 200);
toast.show();
Use offsets (xOffset, yOffset) to fine-tune placement.
Best Practices
Prefer Snackbars for Actionable Feedback
Toasts are ephemeral and non-interactive. Use Snackbars when you need user action (e.g., undo).
Avoid Overuse
Too many toasts can annoy users. Display them only for meaningful events.
Respect Localization
Use string resources (strings.xml) instead of hard-coded text.
Item saved successfully
Common Errors & Solutions
Toast Not Appearing
Cause: Wrong Context
Fix: Use Activity context (this / MainActivity.this)
Long Toast Duration Too Short
Cause: Android handles durations internally
Fix: Use LENGTH_LONG or custom timer logic
When Not to Use Toast
- Critical alerts
- Mandatory acknowledgements
- UI interruptions requiring action
Use Dialogs or Snackbars for those cases.
The post Android Toast Example – Show Messages in Android Apps appeared first on javatechig.com.
]]>The post How to Get Device Information in Android – API & Examples appeared first on javatechig.com.
]]>This updated guide on javatechig.com explains how to access key device information using current Android APIs with Kotlin and Java examples.
Why Collect Device Information?
You might need device info for:
- Crash reports and diagnostics
- Analytics and usage segmentation
- Adapting UI for screen size/resolution
- Feature gating based on OS or device capability
Always respect privacy and avoid collecting personally identifiable information without proper consent.
Basic Device Properties
Device Model & Manufacturer
These identify the device make and brand:
Kotlin
val manufacturer = Build.MANUFACTURER
val model = Build.MODEL
Java
String manufacturer = Build.MANUFACTURER;
String model = Build.MODEL;
Combine them to form a friendly name:
val deviceName = "$manufacturer $model"
OS Version & API Level
val osVersion = Build.VERSION.RELEASE
val apiLevel = Build.VERSION.SDK_INT
This helps you identify the running Android release (e.g., “Android 14”) and program compatibility.
Hardware & Build Info
You can retrieve additional device build properties:
| Property | API |
|---|---|
| Device name | Build.DEVICE |
| Board | Build.BOARD |
| Hardware | Build.HARDWARE |
| Product | Build.PRODUCT |
Example:
val hardware = Build.HARDWARE
Screen Display Metrics
Understanding screen size and density is essential for responsive design.
Kotlin
val metrics = Resources.getSystem().displayMetrics
val width = metrics.widthPixels
val height = metrics.heightPixels
val density = metrics.density
Java
DisplayMetrics metrics = Resources.getSystem().getDisplayMetrics();
int width = metrics.widthPixels;
int height = metrics.heightPixels;
float density = metrics.density;
Use these values for layout calculations or conditional logic for different form factors.
Locale and Time Zone
Locale settings help customize region‑specific behavior:
val locale = Locale.getDefault().toString()
val timeZone = TimeZone.getDefault().id
This is useful for formatting dates, numbers, and language‑specific features.
Battery & Charging State
You can monitor battery level with BatteryManager:
Kotlin
val bm = getSystemService(BATTERY_SERVICE) as BatteryManager
val batteryLevel = bm.getIntProperty(BatteryManager.BATTERY_PROPERTY_CAPACITY)
Knowing the battery helps tailor performance or sync jobs.
Unique Device Identifiers (Scoped)
Due to privacy policies (Android 10+), hardware identifiers are restricted. Use scoped identifiers instead:
Android ID
val androidId = Settings.Secure.getString(contentResolver, Settings.Secure.ANDROID_ID)
This ID is unique per app installation and reset on factory reset.
Note: Avoid using IMEI, MAC, or serial number for analytics — they are restricted.
Build Tags & Fingerprint
For more detailed build identification:
val buildTags = Build.TAGS
val fingerprint = Build.FINGERPRINT
Fingerprint is useful for crash analytics to differentiate builds.
ABI (CPU Architecture)
val supportedABIs = Build.SUPPORTED_ABIS.joinToString(", ")
This lets you know what instruction sets the device supports (e.g., “arm64‑v8a”).
Runtime Capabilities (Feature Checks)
Use PackageManager to check support for features:
val hasCamera = packageManager.hasSystemFeature(PackageManager.FEATURE_CAMERA)
Check for multi‑touch, NFC, sensors, etc., before performing hardware‑specific actions.
Permissions & Privacy
Many identifiers are restricted for privacy. Android disallows:
- IMEI access without special privileges
- MAC address access since Android 6+
- Serial number access since Android 10+
Always:
- Request appropriate permissions
- Declare them in AndroidManifest.xml
- Respect runtime permission prompts
Best Practices (2026 Updated)
- Avoid collecting sensitive identifiers
- Use android_id for app‑scoped ID needs
- Use feature checks instead of exception‑based logic
- Respect user locale and battery state
- Profile device-specific behaviors with metrics
Example: Collecting Device Info in JSON
val deviceInfo = JSONObject().apply {
put("model", Build.MODEL)
put("osVersion", Build.VERSION.RELEASE)
put("api", Build.VERSION.SDK_INT)
put("screen", "$width x $height")
put("locale", Locale.getDefault())
}
This is useful for sending diagnostics or environment info to analytics.
Troubleshooting
Missing Values
Cause: Restricted APIs
Fix: Use scoped identifiers (android_id) and safe fallbacks.
Null or Unavailable Metrics
Cause: Running outside Activity context
Fix: Use proper context (applicationContext) when retrieving metrics.
The post How to Get Device Information in Android – API & Examples appeared first on javatechig.com.
]]>The post Android Asynchronous Image Loader in ListView appeared first on javatechig.com.
]]>ListView without blocking the UI thread is essential for smooth performance. Synchronous loading causes freezes, jank, and poor user experience. Modern Android development mandates asynchronous loading coupled with efficient caching.
This updated guide on javatechig.com explains how to implement asynchronous image loading in a ListView using modern tools, lifecycle-safe practices, and efficient memory handling with both Kotlin and Java.
Why Asynchronous Image Loading Matters
When you load images on the main thread:
- The UI blocks
- Scrolling becomes janky
- Memory spikes
- Users abandon your app
To fix this, images must load off the main thread, updated back onto the UI when ready.
Modern Approach (Recommended): Use Image Loading Libraries
Instead of reinventing the wheel with raw threads or custom AsyncTasks (now discouraged), use well-maintained, optimized libraries:
Popular Libraries
- Glide — Efficient image loading, caching, and lifecycle integration
- Coil — Kotlin-first, coroutine based
- Picasso — Simple, easy to use
These handle threading, caching (memory & disk), and View recycling automatically.
Example: Using Glide in ListView Adapter
Step 1 — Add Dependency
In module build.gradle:
implementation 'com.github.bumptech.glide:glide:4.15.1'
kapt 'com.github.bumptech.glide:compiler:4.15.1'
Adapter Implementation (Kotlin)
class ImageListAdapter(private val context: Context, private val items: List)
: BaseAdapter() {
override fun getCount() = items.size
override fun getItem(position: Int) = items[position]
override fun getItemId(position: Int) = position.toLong()
override fun getView(position: Int, convertView: View?, parent: ViewGroup): View {
val view = convertView ?: LayoutInflater.from(context)
.inflate(R.layout.list_item, parent, false)
val imageView = view.findViewById(R.id.imageView)
Glide.with(context)
.load(items[position])
.placeholder(R.drawable.placeholder)
.error(R.drawable.error_image)
.into(imageView)
return view
}
}
Kotlin libraries like Coil work similarly:
imageView.load(items[position]) {
placeholder(R.drawable.placeholder)
error(R.drawable.error_image)
}
Java ListView Adapter (Glide)
public class ImageListAdapter extends BaseAdapter {
private Context context;
private List images;
public ImageListAdapter(Context context, List images) {
this.context = context;
this.images = images;
}
@Override
public int getCount() { return images.size(); }
@Override
public Object getItem(int position) { return images.get(position); }
@Override
public long getItemId(int position) { return position; }
@Override
public View getView(int position, View convertView, ViewGroup parent) {
if (convertView == null) {
convertView = LayoutInflater.from(context)
.inflate(R.layout.list_item, parent, false);
}
ImageView imageView = convertView.findViewById(R.id.imageView);
Glide.with(context)
.load(images.get(position))
.placeholder(R.drawable.placeholder)
.error(R.drawable.error_image)
.into(imageView);
return convertView;
}
}
Why ViewHolder & Recycling Matters
ListView reuses item views. Without caching and proper recycling:
- Images may flicker
- Wrong images can appear
- Memory spikes
Using libraries like Glide or Coil ensures images cancel old requests when views are reused.
Using ViewHolder Explicitly (Legacy Example)
class ViewHolder(view: View) {
val imageView: ImageView = view.findViewById(R.id.imageView)
}
override fun getView(position: Int, convertView: View?, parent: ViewGroup): View {
val holder: ViewHolder
val view: View
if (convertView == null) {
view = LayoutInflater.from(context).inflate(R.layout.list_item, parent, false)
holder = ViewHolder(view)
view.tag = holder
} else {
view = convertView
holder = convertView.tag as ViewHolder
}
Glide.with(context)
.load(items[position])
.into(holder.imageView)
return view
}
Even with ViewHolder, libraries handle background loading and caching for you.
Caching Benefits
Image loading libraries include:
Memory Cache
Quick retrieval during scrolling
Disk Cache
Persistent store for repeated requests
These significantly improve performance and reduce network overhead.
Common Issues & Fixes
ListView Scroll Lag
Cause: Heavy image decoding on main thread
Fix: Always use libraries with background decoding
Wrong Image Appears
Cause: View reuse before load finishes
Fix: Libraries cancel previous requests automatically
OOM (OutOfMemory)
Cause: Large bitmaps kept in memory
Fix: Use placeholder, resizing, and proper caching
Best Practices (2026 Updated)
- Prefer RecyclerView over ListView for modern apps
- Use Glide / Coil / Picasso for async image loading
- Resize images to appropriate sizes before loading
- Use disk and memory caching effectively
- Avoid AsyncTask — prefer library managed threads
- Respect lifecycle with Glide/Coil integrations
When ListView May Still Be Used
While RecyclerView is recommended for most modern apps due to flexibility and performance, legacy codebases may still use ListView. In such cases, using Glide or Coil ensures acceptable performance.
The post Android Asynchronous Image Loader in ListView appeared first on javatechig.com.
]]>