دسته: اخبار اندروید

  • Samsung made a two-toned Galaxy Ring, but you probably won’t be able to get one

    Samsung made a two-toned Galaxy Ring, but you probably won’t be able to get one


    Samsung Galaxy Ring 4

    Lanh Nguyen / Android Authority

    TL;DR

    • Samsung is selling a limited edition two-tone Galaxy Ring along with the Galaxy S25 Edge.
    • The two-toned smart ring is a mix of Titanium Silver and Titanium Black.
    • You can get a 20% discount on the smart ring if you buy it together with the Edge.
    • The smart ring is only available in South Korea.

    After months of waiting, Samsung has finally launched the Galaxy S25 Edge. Although this phone is an exciting new addition to the Galaxy lineup, there’s another announcement that seems to have flown under the radar. While everyone’s attention is currently on the Edge, you may have missed that Samsung quietly revealed it is selling a limited edition Galaxy Ring.

    In a press release for the Galaxy S25 Edge on its Korean website, Samsung snuck in an announcement about a new Galaxy Ring. There’s nothing different about this smart ring spec-wise, but it does feature a new finish. Although the company didn’t share any pictures, Samsung calls it “Two-Tone Titanium Black.” This ring would be a mix of the Titanium Black and the Titanium Silver colorways.

    Unfortunately, the new finish will only be available in South Korea at the Samsung Gangnam store starting on May 14 and will be sold in limited quantities. If you happen to be in the market, however, buying one along with an S25 Edge will net you 20% off the smart ring plus 100,000 won in Samsung Electronics membership points.

    Samsung does not mention this new Galaxy Ring in any of its other press releases. It’s also unknown how many of these limited edition rings were made. Hopefully, Samsung will change its mind and make this new finish available in other markets.

    Got a tip? Talk to us! Email our staff at news@androidauthority.com. You can stay anonymous or get credit for the info, it’s your choice.



    Source link

  • One UI 8 could let you listen to your Now Brief (APK teardown)

    One UI 8 could let you listen to your Now Brief (APK teardown)


    samsung now brief midday hero

    Joe Maring / Android Authority

    TL;DR

    • Samsung is working on a Listen Brief button in One UI 8, according to an Android Authority teardown.
    • This seems to be an audio version of the Now Brief feature, which offers a personalized summary of your morning, afternoon, or evening.
    • It looks like Samsung could offer play, pause, and stop controls for Listen Brief, along with your choice of text-to-speech engine.

    Samsung introduced the Now Brief feature on the Galaxy S25 series back in January, delivering a personalized summary of your day. Now Brief delivers this summary in text form, but it looks like the company is working on a new way to access them.

    You’re reading an Authority Insights story on Android Authority. Discover Authority Insights for more exclusive reports, app teardowns, leaks, and in-depth tech coverage you won’t find anywhere else.

    An APK teardown helps predict features that may arrive on a service in the future based on work-in-progress code. However, it is possible that such predicted features may not make it to a public release.

    We dug into the One UI 8 firmware and discovered that Samsung is working on a “Listen Brief” button. Check out our screenshots of the code snippets below.

    Now Brief offers a summary of your morning, afternoon, or evening. This summary includes weather forecasts, upcoming calendar events, traffic updates, and news. However, the “Listen Brief” feature seems to be an audio version of Now Brief, allowing you to get all these details without reading.

    One of the screenshots also hints that Listen Brief users can choose between Samsung and Google’s text-to-speech engines. Furthermore, another screenshot suggests that users can pause, play, or stop the audio briefing.

    This could be a useful way to get your daily briefing, and I can see it being handy if you’re driving or otherwise preoccupied. It would also be a great addition for visually impaired people or users with different accessibility needs.

    In saying so, there are plenty of other ways Samsung can improve this feature. Colleague Joe Maring felt disappointed by Now Brief after using it for a few weeks, noting that it was a glorified news and weather app. Joe specifically called for additions like sports scores, email integration, and package information. So we hope Listen Brief isn’t the only improvement to Now Brief in One UI 8.

    Got a tip? Talk to us! Email our staff at news@androidauthority.com. You can stay anonymous or get credit for the info, it’s your choice.



    Source link

  • Zoho Achieves 6x Faster Logins with Passkey and Credential Manager Integration



    Posted by Niharika Arora – Senior Developer Relations Engineer, Joseph Lewis – Staff Technical Writer, and Kumareshwaran Sreedharan – Product Manager, Zoho.

    As an Android developer, you’re constantly looking for ways to enhance security, improve user experience, and streamline development. Zoho, a comprehensive cloud-based software suite focused on security and seamless experiences, achieved significant improvements by adopting passkeys in their OneAuth Android app.

    Since integrating passkeys in 2024, Zoho achieved login speeds up to 6x faster than previous methods and a 31% month-over-month (MoM) growth in passkey adoption.

    This case study examines Zoho’s adoption of passkeys and Android’s Credential Manager API to address authentication difficulties. It details the technical implementation process and highlights the impactful results.

    Overcoming authentication challenges

    Zoho utilizes a combination of authentication methods to protect user accounts. This included Zoho OneAuth, their own multi-factor authentication (MFA) solution, which supported both password-based and passwordless authentication using push notifications, QR codes, and time-based one-time passwords (TOTP). Zoho also supported federated logins, allowing authentication through Security Assertion Markup Language (SAML) and other third-party identity providers.

    Challenges

    Zoho, like many organizations, aimed to improve authentication security and user experience while reducing operational burdens. The primary challenges that led to the adoption of passkeys included:

      • Security vulnerabilities: Traditional password-based methods left users susceptible to phishing attacks and password breaches.
      • User friction: Password fatigue led to forgotten passwords, frustration, and increased reliance on cumbersome recovery processes.
      • Operational inefficiencies: Handling password resets and MFA issues generated significant support overhead.
      • Scalability concerns: A growing user base demanded a more secure and efficient authentication solution.

    Why the shift to passkeys?

    Passkeys were implemented in Zoho’s apps to address authentication challenges by offering a passwordless approach that significantly improves security and user experience. This solution leverages phishing-resistant authentication, cloud-synchronized credentials for effortless cross-device access, and biometrics (such as a fingerprint or facial recognition), PIN, or pattern for secure logins, thereby reducing the vulnerabilities and inconveniences associated with traditional passwords.

    By adopting passkeys with Credential Manager, Zoho cut login times by up to 6x, slashed password-related support costs, and saw strong user adoption – doubling passkey sign-ins in 4 months with 31% MoM growth. Zoho users now enjoy faster, easier logins and phishing-resistant security.

    Quote card reads 'Cloud Lion now enjoys logins that are 30% faster and more secure using passkeys – allowing us to use our thumb instead of a password. With passkeys, we can also protect our critical business data against phishing and brute force attacks.' – Fabrice Venegas, Founder, Cloud Lion (a Zoho integration partner)

    Implementation with Credential Manager on Android

    So, how did Zoho achieve these results? They used Android’s Credential Manager API, the recommended Jetpack library for implementing authentication on Android.

    Credential Manager provides a unified API that simplifies handling of the various authentication methods. Instead of juggling different APIs for passwords, passkeys, and federated logins (like Sign in with Google), you use a single interface.

    Implementing passkeys at Zoho required both client-side and server-side adjustments. Here’s a detailed breakdown of the passkey creation, sign-in, and server-side implementation process.

    Passkey creation

    Passkey creation in OneAuth on a small screen mobile device

    To create a passkey, the app first retrieves configuration details from Zoho’s server. This process includes a unique verification, such as a fingerprint or facial recognition. This verification data, formatted as a requestJson string), is used by the app to build a CreatePublicKeyCredentialRequest. The app then calls the credentialManager.createCredential method, which prompts the user to authenticate using their device screen lock (biometrics, fingerprint, PIN, etc.).

    Upon successful user confirmation, the app receives the new passkey credential data, sends it back to Zoho’s server for verification, and the server then stores the passkey information linked to the user’s account. Failures or user cancellations during the process are caught and handled by the app.

    Sign-in

    The Zoho Android app initiates the passkey sign-in process by requesting sign-in options, including a unique challenge, from Zoho’s backend server. The app then uses this data to construct a GetCredentialRequest, indicating it will authenticate with a passkey. It then invokes the Android CredentialManager.getCredential() API with this request. This action triggers a standardized Android system interface, prompting the user to choose their Zoho account (if multiple passkeys exist) and authenticate using their device’s configured screen lock (fingerprint, face scan, or PIN). After successful authentication, Credential Manager returns a signed assertion (proof of login) to the Zoho app. The app forwards this assertion to Zoho’s server, which verifies the signature against the user’s stored public key and validates the challenge, completing the secure sign-in process.

    Server-side implementation

    Zoho’s transition to supporting passkeys benefited from their backend systems already being FIDO WebAuthn compliant, which streamlined the server-side implementation process. However, specific modifications were still necessary to fully integrate passkey functionality.

    The most significant challenge involved adapting the credential storage system. Zoho’s existing authentication methods, which primarily used passwords and FIDO security keys for multi-factor authentication, required different storage approaches than passkeys, which are based on cryptographic public keys. To address this, Zoho implemented a new database schema specifically designed to securely store passkey public keys and related data according to WebAuthn protocols. This new system was built alongside a lookup mechanism to validate and retrieve credentials based on user and device information, ensuring backward compatibility with older authentication methods.

    Another server-side adjustment involved implementing the ability to handle requests from Android devices. Passkey requests originating from Android apps use a unique origin format (android:apk-key-hash:example) that is distinct from standard web origins that use a URI-based format (https://example.com/app). The server logic needed to be updated to correctly parse this format, extract the SHA-256 fingerprint hash of the app’s signing certificate, and validate it against a pre-registered list. This verification step ensures that authentication requests genuinely originate from Zoho’s Android app and protects against phishing attacks.

    This code snippet demonstrates how the server checks for the Android-specific origin format and validates the certificate hash:

    val origin: String = clientData.getString("origin")
    
    if (origin.startsWith("android:apk-key-hash:")) { 
        val originSplit: List<String> = origin.split(":")
        if (originSplit.size > 3) {
                   val androidOriginHashDecoded: ByteArray = Base64.getDecoder().decode(originSplit[3])
    
                    if (!androidOriginHashDecoded.contentEquals(oneAuthSha256FingerPrint)) {
                throw IAMException(IAMErrorCode.WEBAUTH003)
            }
        } else {
            // Optional: Handle the case where the origin string is malformed    }
    }
    

    Error handling

    Zoho implemented robust error handling mechanisms to manage both user-facing and developer-facing errors. A common error, CreateCredentialCancellationException, appeared when users manually canceled their passkey setup. Zoho tracked the frequency of this error to assess potential UX improvements. Based on Android’s UX recommendations, Zoho took steps to better educate their users about passkeys, ensure users were aware of passkey availability, and promote passkey adoption during subsequent sign-in attempts.

    This code example demonstrates Zoho’s approach for how they handled their most common passkey creation errors:

    private fun handleFailure(e: CreateCredentialException) {
        val msg = when (e) {
            is CreateCredentialCancellationException -> {
                Analytics.addAnalyticsEvent(eventProtocol: "PASSKEY_SETUP_CANCELLED", GROUP_NAME)
                Analytics.addNonFatalException(e)
                "The operation was canceled by the user."
            }
            is CreateCredentialInterruptedException -> {
                Analytics.addAnalyticsEvent(eventProtocol: "PASSKEY_SETUP_INTERRUPTED", GROUP_NAME)
                Analytics.addNonFatalException(e)
                "Passkey setup was interrupted. Please try again."
            }
            is CreateCredentialProviderConfigurationException -> {
                Analytics.addAnalyticsEvent(eventProtocol: "PASSKEY_PROVIDER_MISCONFIGURED", GROUP_NAME)
                Analytics.addNonFatalException(e)
                "Credential provider misconfigured. Contact support."
            }
            is CreateCredentialUnknownException -> {
                Analytics.addAnalyticsEvent(eventProtocol: "PASSKEY_SETUP_UNKNOWN_ERROR", GROUP_NAME)
                Analytics.addNonFatalException(e)
                "An unknown error occurred during Passkey setup."
            }
            is CreatePublicKeyCredentialDomException -> {
                Analytics.addAnalyticsEvent(eventProtocol: "PASSKEY_WEB_AUTHN_ERROR", GROUP_NAME)
                Analytics.addNonFatalException(e)
                "Passkey creation failed: ${e.domError}"
            }
            else -> {
                Analytics.addAnalyticsEvent(eventProtocol: "PASSKEY_SETUP_FAILED", GROUP_NAME)
                Analytics.addNonFatalException(e)
                "An unexpected error occurred. Please try again."
            }
        }
    }
    

    Testing passkeys in intranet environments

    Zoho faced an initial challenge in testing passkeys within a closed intranet environment. The Google Password Manager verification process for passkeys requires public domain access to validate the relying party (RP) domain. However, Zoho’s internal testing environment lacked this public Internet access, causing the verification process to fail and hindering successful passkey authentication testing. To overcome this, Zoho created a publicly accessible test environment, which included hosting a temporary server with an asset link file and domain validation.

    This example from the assetlinks.json file used in Zoho’s public test environment demonstrates how to associate the relying party domain with the specified Android app for passkey validation.

    [
        {
            "relation": [
                "delegate_permission/common.handle_all_urls",
                "delegate_permission/common.get_login_creds"
            ],
            "target": {
                "namespace": "android_app",
                "package_name": "com.zoho.accounts.oneauth",
                "sha256_cert_fingerprints": [
                    "SHA_HEX_VALUE" 
                ]
            }
        }
    ]
    

    Integrate with an existing FIDO server

    Android’s passkey system utilizes the modern FIDO2 WebAuthn standard. This standard requires requests in a specific JSON format, which helps maintain consistency between native applications and web platforms. To enable Android passkey support, Zoho did minor compatibility and structural changes to correctly generate and process requests that adhere to the required FIDO2 JSON structure.

    This server update involved several specific technical adjustments:

    // Convert rawId bytes to a standard Base64 encoded string for storage
    val base64RawId: String = Base64.getEncoder().encodeToString(rawId.toByteArray())
    

        2. Transport list format: To ensure consistent data processing, the server logic handles lists of transport mechanisms (such as USB, NFC, and Bluetooth, which specify how the authenticator communicated) as JSON arrays.

        3. Client data alignment: The Zoho team adjusted how the server encodes and decodes the clientDataJson field. This ensures the data structure aligns precisely with the expectations of Zoho’s existing internal APIs. The example below illustrates part of the conversion logic applied to client data before the server processes it:

    private fun convertForServer(type: String): String {
        val clientDataBytes = BaseEncoding.base64().decode(type)
        val clientDataJson = JSONObject(String(clientDataBytes, StandardCharsets.UTF_8))
        val clientJson = JSONObject()
        val challengeFromJson = clientDataJson.getString("challenge")
        // 'challenge' is a technical identifier/token, not localizable text.
        clientJson.put("challenge", BaseEncoding.base64Url()
            .encode(challengeFromJson.toByteArray(StandardCharsets.UTF_8))) 
    
        clientJson.put("origin", clientDataJson.getString("origin"))
        clientJson.put("type", clientDataJson.getString("type"))
        clientJson.put("androidPackageName", clientDataJson.getString("androidPackageName"))
        return BaseEncoding.base64().encode(clientJson.toString().toByteArray())
    }
    

    User guidance and authentication preferences

    A central part of Zoho’s passkey strategy involved encouraging user adoption while providing flexibility to align with different organizational requirements. This was achieved through careful UI design and policy controls.

    Zoho recognized that organizations have varying security needs. To accommodate this, Zoho implemented:

      • Admin enforcement: Through the Zoho Directory admin panel, administrators can designate passkeys as the mandatory, default authentication method for their entire organization. When this policy is enabled, employees are required to set up a passkey upon their next login and use it going forward.
      • User choice: If an organization does not enforce a specific policy, individual users maintain control. They can choose their preferred authentication method during login, selecting from passkeys or other configured options via their authentication settings.

    To make adopting passkeys appealing and straightforward for end-users, Zoho implemented:

      • Easy setup: Zoho integrated passkey setup directly into the Zoho OneAuth mobile app (available for both Android and iOS). Users can conveniently configure their passkeys within the app at any time, smoothing the transition.
      • Consistent access: Passkey support was implemented across key user touchpoints, ensuring users can register and authenticate using passkeys via:
          • The Zoho OneAuth mobile app (Android & iOS);

    This method ensured that the process of setting up and using passkeys was accessible and integrated into the platforms they already use, regardless of whether it was mandated by an admin or chosen by the user. You can learn more about how to create smooth user flows for passkey authentication by exploring our comprehensive passkeys user experience guide.

    Impact on developer velocity and integration efficiency

    Credential Manager, as a unified API, also helped improve developer productivity compared to older sign-in flows. It reduced the complexity of handling multiple authentication methods and APIs separately, leading to faster integration, from months to weeks, and fewer implementation errors. This collectively streamlined the sign-in process and improved overall reliability.

    By implementing passkeys with Credential Manager, Zoho achieved significant, measurable improvements across the board:

      • Dramatic speed improvements
          • 2x faster login compared to traditional password authentication.
          • 4x faster login compared to username or mobile number with email or SMS OTP authentication.
          • 6x faster login compared to username, password, and SMS or authenticator OTP authentication.
      • Reduced support costs
          • Reduced password-related support requests, especially for forgotten passwords.
          • Lower costs associated with SMS-based 2FA, as existing users can onboard directly with passkeys.
      • Strong user adoption & enhanced security:
          • Passkey sign-ins doubled in just 4 months, showing high user acceptance.
          • Users migrating to passkeys are fully protected from common phishing and password breach threats.
          • With 31% MoM adoption growth, more users are benefiting daily from enhanced security against vulnerabilities like phishing and SIM swaps.

    Recommendations and best practices

    To successfully implement passkeys on Android, developers should consider the following best practices:

      • Leverage Android’s Credential Manager API:
          • Credential Manager simplifies credential retrieval, reducing developer effort and ensuring a unified authentication experience.
          • Handles passwords, passkeys, and federated login flows in a single interface.
      • Ensure data encoding consistency while migrating from other FIDO authentication solutions:
          • Make sure you handle consistent formatting for all inputs/outputs while migrating from other FIDO authentication solutions such as FIDO security keys.
      • Optimize error handling and logging:
          • Implement robust error handling for a seamless user experience.
          • Provide localized error messages and use detailed logs to debug and resolve unexpected failures.
      • Educate users on passkey recovery options:
          • Prevent lockout scenarios by proactively guiding users on recovery options.
      • Monitor adoption metrics and user feedback:
          • Track user engagement, passkey adoption rates, and login success rates to keep optimizing user experience.
          • Conduct A/B testing on different authentication flows to improve conversion and retention.

    Passkeys, combined with the Android Credential Manager API, offer a powerful, unified authentication solution that enhances security while simplifying user experience. Passkeys significantly reduce phishing risks, credential theft, and unauthorized access. We encourage developers to try out the experience in their app and bring the most secure authentication to their users.

    Get started with passkeys and Credential Manager

    Get hands on with passkeys and Credential Manager on Android using our public sample code.

    If you have any questions or issues, you can share with us through the Android Credentials issues tracker.



    Source link

  • Prepare your apps for Google Play’s 16 KB page size compatibility requirement



    Posted by Dan Brown – Product Manager, Google Play

    Google Play empowers you to manage and distribute your innovative and trusted apps and games to billions of users around the world across the entire breadth of Android devices, and historically, all Android devices have managed memory in 4 KB pages.

    As device manufacturers equip devices with more RAM to optimize performance, many will adopt larger page sizes like 16 KB. Android 15 introduces support for the increased page size, ensuring your app can run on these evolving devices and benefit from the associated performance gains.

    Starting November 1st, 2025, all new apps and updates to existing apps submitted to Google Play and targeting Android 15+ devices must support 16 KB page sizes.

    This is a key technical requirement to ensure your users can benefit from the performance enhancements on newer devices and prepares your apps for the platform’s future direction of improved performance on newer hardware. Without recompiling to support 16 KB pages, your app might not function correctly on these devices when they become more widely available in future Android releases.

    We’ve seen that 16 KB can help with:

      • Faster app launches: See improvements ranging from 3% to 30% for various apps.
      • Improved battery usage: Experience an average gain of 4.5%.
      • Quicker camera starts: Launch the camera 4.5% to 6.6% faster.
      • Speedier system boot-ups: Boot Android devices approximately 8% faster.

    We recommend checking your apps early especially for dependencies that might not yet be 16 KB compatible. Many popular SDK providers, like React Native and Flutter, already offer compatible versions. For game developers, several leading game engines, such as Unity, support 16 KB, with support for Unreal Engine coming soon.

    Reaching 16 KB compatibility

    A substantial number of apps are already compatible, so your app may already work seamlessly with this requirement. For most of those that need to make adjustments, we expect the changes to be minimal.

      • Apps with no native code should be compatible without any changes at all.
      • Apps using libraries or SDKs that contain native code may need to update these to a compatible version.
      • Apps with native code may need to recompile with a more recent toolchain and check for any code with incompatible low level memory management.

    Our December blog post, Get your apps ready for 16 KB page size devices, provides a more detailed technical explanation and guidance on how to prepare your apps.

    Check your app’s compatibility now

    It’s easy to see if your app bundle already supports 16 KB memory page sizes. Visit the app bundle explorer page in Play Console to check your app’s build compliance and get guidance on where your app may need updating.

    App bundle explorer in Play Console

    Beyond the app bundle explorer, make sure to also test your app in a 16 KB environment. This will help you ensure users don’t experience any issues and that your app delivers its best performance.

    For more information, check out the full documentation.

    Thank you for your continued support in bringing delightful, fast, and high-performance experiences to users across the breadth of devices Play supports. We look forward to seeing the enhanced experiences you’ll deliver with 16 KB support.



    Source link

  • Galaxy S25 Edge photo leak lands ahead of Monday launch

    Galaxy S25 Edge photo leak lands ahead of Monday launch


    Samsung Galaxy S25 Edge (2)

    Paul Jones / Android Authority

    TL;DR

    • Samsung is just about to launch the Galaxy S25 Edge, an extra-thin variant of this year’s S25 flagship.
    • Ahead of Monday’s Unpacked event, new promotional imagery of the hardware has leaked.
    • We’re also getting a new look at a few cases and Samsung’s screen protector.

    It’s official: In just a few short days, on May 12, Samsung is formally launching the Galaxy S25 Edge. Depending on who you ask, the controversial extra-thin smartphone is either the most desirable flagship Samsung’s cooked up in a while, or a symbol of everything that’s wrong with modern phone design trends. You’ll be able to get your hands on the phone and make up your own mind soon. Until then, why wait all weekend for the official reveal when we’ve got a new leak to check out today that lays bare the S25 Edge and its accessories?

    What we’ve got here appears to be some very official-looking Samsung imagery shared by Android Headlines, detailing the S25 Edge and some of its stand-out features. That side-view teaser we first checked out back at the start of the month returns once again, though now in sharp focus, highlighting the handset’s slim build.

    galaxy s25 edge ah leak 06

    We can glean confirmation of a few camera details from these graphics, and spot that mention of ingress protection, but sadly these paint a less than complete picture of the hardware. While there’s no denying that’s a very svelte handset we’re looking at, Samsung doesn’t seem to be going out of its way to highlight the actual measurement (which we’ve heard before as 5.8mm thin) — not in this imagery, anyway.

    Although these pics aren’t overloaded with juicy specs, this image dump does manage to give us a nice preview of some of the cases set to be available for the Galaxy S25 Edge. We’re not saying that an extra-thin handset is necessarily going to be that much easier to accidentally drop, but we’d sure like to be covered, all the same. First up, we’ve got Samsung’s silicone case:

    If that one’s not to your taste, Samsung will also be bringing back its “Kindsuit” cases with that classy leather-esque finish:

    As you can see, all these will be available in a variety of colors, coordinated to match the hues the S25 Edge itself will arrive in. But if you’d rather just let the phones shine through, that’s an option, too:

    Lest you think we were playing a little fast and loose with that “accessory” label when we really meant “just cases,” we’re wrapping up this leak with Samsung’s screen-protection solution for the S25 Edge:

    Check back with Android Authority this coming Monday, May 12, for full coverage of the Samsung Galaxy S25 Edge launch.

    Got a tip? Talk to us! Email our staff at news@androidauthority.com. You can stay anonymous or get credit for the info, it’s your choice.



    Source link

  • Building delightful Android camera and media experiences



    Posted by Donovan McMurray, Mayuri Khinvasara Khabya, Mozart Louis, and Nevin Mital – Developer Relations Engineers

    Hello Android Developers!

    We are the Android Developer Relations Camera & Media team, and we’re excited to bring you something a little different today. Over the past several months, we’ve been hard at work writing sample code and building demos that showcase how to take advantage of all the great potential Android offers for building delightful user experiences.

    Some of these efforts are available for you to explore now, and some you’ll see later throughout the year, but for this blog post we thought we’d share some of the learnings we gathered while going through this exercise.

    Grab your favorite Android plush or rubber duck, and read on to see what we’ve been up to!

    Future-proof your app with Jetpack

    Nevin Mital

    One of our focuses for the past several years has been improving the developer tools available for video editing on Android. This led to the creation of the Jetpack Media3 Transformer APIs, which offer solutions for both single-asset and multi-asset video editing preview and export. Today, I’d like to focus on the Composition demo app, a sample app that showcases some of the multi-asset editing experiences that Transformer enables.

    I started by adding a custom video compositor to demonstrate how you can arrange input video sequences into different layouts for your final composition, such as a 2×2 grid or a picture-in-picture overlay. You can customize this by implementing a VideoCompositorSettings and overriding the getOverlaySettings method. This object can then be set when building your Composition with setVideoCompositorSettings.

    Here is an example for the 2×2 grid layout:

    object : VideoCompositorSettings {
      ...
    
      override fun getOverlaySettings(inputId: Int, presentationTimeUs: Long): OverlaySettings {
        return when (inputId) {
          0 -> { // First sequence is placed in the top left
            StaticOverlaySettings.Builder()
              .setScale(0.5f, 0.5f)
              .setOverlayFrameAnchor(0f, 0f) // Middle of overlay
              .setBackgroundFrameAnchor(-0.5f, 0.5f) // Top-left section of background
              .build()
          }
    
          1 -> { // Second sequence is placed in the top right
            StaticOverlaySettings.Builder()
              .setScale(0.5f, 0.5f)
              .setOverlayFrameAnchor(0f, 0f) // Middle of overlay
              .setBackgroundFrameAnchor(0.5f, 0.5f) // Top-right section of background
              .build()
          }
    
          2 -> { // Third sequence is placed in the bottom left
            StaticOverlaySettings.Builder()
              .setScale(0.5f, 0.5f)
              .setOverlayFrameAnchor(0f, 0f) // Middle of overlay
              .setBackgroundFrameAnchor(-0.5f, -0.5f) // Bottom-left section of background
              .build()
          }
    
          3 -> { // Fourth sequence is placed in the bottom right
            StaticOverlaySettings.Builder()
              .setScale(0.5f, 0.5f)
              .setOverlayFrameAnchor(0f, 0f) // Middle of overlay
              .setBackgroundFrameAnchor(0.5f, -0.5f) // Bottom-right section of background
              .build()
          }
    
          else -> {
            StaticOverlaySettings.Builder().build()
          }
        }
      }
    }
    

    Since getOverlaySettings also provides a presentation time, we can even animate the layout, such as in this picture-in-picture example:

    moving image of picture in picture on a mobile device

    Next, I spent some time migrating the Composition demo app to use Jetpack Compose. With complicated editing flows, it can help to take advantage of as much screen space as is available, so I decided to use the supporting pane adaptive layout. This way, the user can fine-tune their video creation on the preview screen, and export options are only shown at the same time on a larger display. Below, you can see how the UI dynamically adapts to the screen size on a foldable device, when switching from the outer screen to the inner screen and vice versa.

    What’s great is that by using Jetpack Media3 and Jetpack Compose, these features also carry over seamlessly to other devices and form factors, such as the new Android XR platform. Right out-of-the-box, I was able to run the demo app in Home Space with the 2D UI I already had. And with some small updates, I was even able to adapt the UI specifically for XR with features such as multiple panels, and to take further advantage of the extra space, an Orbiter with playback controls for the editing preview.

    moving image of suportive pane adaptive layout

    What’s great is that by using Jetpack Media3 and Jetpack Compose, these features also carry over seamlessly to other devices and form factors, such as the new Android XR platform. Right out-of-the-box, I was able to run the demo app in Home Space with the 2D UI I already had. And with some small updates, I was even able to adapt the UI specifically for XR with features such as multiple panels, and to take further advantage of the extra space, an Orbiter with playback controls for the editing preview.

    moving image of sequential composition preview in Android XR

    Orbiter(
      position = OrbiterEdge.Bottom,
      offset = EdgeOffset.inner(offset = MaterialTheme.spacing.standard),
      alignment = Alignment.CenterHorizontally,
      shape = SpatialRoundedCornerShape(CornerSize(28.dp))
    ) {
      Row (horizontalArrangement = Arrangement.spacedBy(MaterialTheme.spacing.mini)) {
        // Playback control for rewinding by 10 seconds
        FilledTonalIconButton({ viewModel.seekBack(10_000L) }) {
          Icon(
            painter = painterResource(id = R.drawable.rewind_10),
            contentDescription = "Rewind by 10 seconds"
          )
        }
        // Playback control for play/pause
        FilledTonalIconButton({ viewModel.togglePlay() }) {
          Icon(
            painter = painterResource(id = R.drawable.rounded_play_pause_24),
            contentDescription = 
                if(viewModel.compositionPlayer.isPlaying) {
                    "Pause preview playback"
                } else {
                    "Resume preview playback"
                }
          )
        }
        // Playback control for forwarding by 10 seconds
        FilledTonalIconButton({ viewModel.seekForward(10_000L) }) {
          Icon(
            painter = painterResource(id = R.drawable.forward_10),
            contentDescription = "Forward by 10 seconds"
          )
        }
      }
    }
    

    Jetpack libraries unlock premium functionality incrementally

    Donovan McMurray

    Not only do our Jetpack libraries have you covered by working consistently across existing and future devices, but they also open the doors to advanced functionality and custom behaviors to support all types of app experiences. In a nutshell, our Jetpack libraries aim to make the common case very accessible and easy, and it has hooks for adding more custom features later.

    We’ve worked with many apps who have switched to a Jetpack library, built the basics, added their critical custom features, and actually saved developer time over their estimates. Let’s take a look at CameraX and how this incremental development can supercharge your process.

    // Set up CameraX app with preview and image capture.
    // Note: setting the resolution selector is optional, and if not set,
    // then a default 4:3 ratio will be used.
    val aspectRatioStrategy = AspectRatioStrategy(
      AspectRatio.RATIO_16_9, AspectRatioStrategy.FALLBACK_RULE_NONE)
    var resolutionSelector = ResolutionSelector.Builder()
      .setAspectRatioStrategy(aspectRatioStrategy)
      .build()
    
    private val previewUseCase = Preview.Builder()
      .setResolutionSelector(resolutionSelector)
      .build()
    private val imageCaptureUseCase = ImageCapture.Builder()
      .setResolutionSelector(resolutionSelector)
      .setCaptureMode(ImageCapture.CAPTURE_MODE_MINIMIZE_LATENCY)
      .build()
    
    val useCaseGroupBuilder = UseCaseGroup.Builder()
      .addUseCase(previewUseCase)
      .addUseCase(imageCaptureUseCase)
    
    cameraProvider.unbindAll()
    
    camera = cameraProvider.bindToLifecycle(
      this,  // lifecycleOwner
      CameraSelector.DEFAULT_BACK_CAMERA,
      useCaseGroupBuilder.build(),
    )
    

    After setting up the basic structure for CameraX, you can set up a simple UI with a camera preview and a shutter button. You can use the CameraX Viewfinder composable which displays a Preview stream from a CameraX SurfaceRequest.

    // Create preview
    Box(
      Modifier
        .background(Color.Black)
        .fillMaxSize(),
      contentAlignment = Alignment.Center,
    ) {
      surfaceRequest?.let {
        CameraXViewfinder(
          modifier = Modifier.fillMaxSize(),
          implementationMode = ImplementationMode.EXTERNAL,
          surfaceRequest = surfaceRequest,
         )
      }
      Button(
        onClick = onPhotoCapture,
        shape = CircleShape,
        colors = ButtonDefaults.buttonColors(containerColor = Color.White),
        modifier = Modifier
          .height(75.dp)
          .width(75.dp),
      )
    }
    
    fun onPhotoCapture() {
      // Not shown: defining the ImageCapture.OutputFileOptions for
      // your saved images
      imageCaptureUseCase.takePicture(
        outputOptions,
        ContextCompat.getMainExecutor(context),
        object : ImageCapture.OnImageSavedCallback {
          override fun onError(exc: ImageCaptureException) {
            val msg = "Photo capture failed."
            Toast.makeText(context, msg, Toast.LENGTH_SHORT).show()
          }
    
          override fun onImageSaved(output: ImageCapture.OutputFileResults) {
            val savedUri = output.savedUri
            if (savedUri != null) {
              // Do something with the savedUri if needed
            } else {
              val msg = "Photo capture failed."
              Toast.makeText(context, msg, Toast.LENGTH_SHORT).show()
            }
          }
        },
      )
    }
    

    You’re already on track for a solid camera experience, but what if you wanted to add some extra features for your users? Adding filters and effects are easy with CameraX’s Media3 effect integration, which is one of the new features introduced in CameraX 1.4.0.

    Here’s how simple it is to add a black and white filter from Media3’s built-in effects.

    val media3Effect = Media3Effect(
      application,
      PREVIEW or IMAGE_CAPTURE,
      ContextCompat.getMainExecutor(application),
      {},
    )
    media3Effect.setEffects(listOf(RgbFilter.createGrayscaleFilter()))
    useCaseGroupBuilder.addEffect(media3Effect)
    

    The Media3Effect object takes a Context, a bitwise representation of the use case constants for targeted UseCases, an Executor, and an error listener. Then you set the list of effects you want to apply. Finally, you add the effect to the useCaseGroupBuilder we defined earlier.

    moving image of sequential composition preview in Android XR

    (Left) Our camera app with no filter applied. 
     (Right) Our camera app after the createGrayscaleFilter was added.

    There are many other built-in effects you can add, too! See the Media3 Effect documentation for more options, like brightness, color lookup tables (LUTs), contrast, blur, and many other effects.

    To take your effects to yet another level, it’s also possible to define your own effects by implementing the GlEffect interface, which acts as a factory of GlShaderPrograms. You can implement a BaseGlShaderProgram’s drawFrame() method to implement a custom effect of your own. A minimal implementation should tell your graphics library to use its shader program, bind the shader program’s vertex attributes and uniforms, and issue a drawing command.

    Jetpack libraries meet you where you are and your app’s needs. Whether that be a simple, fast-to-implement, and reliable implementation, or custom functionality that helps the critical user journeys in your app stand out from the rest, Jetpack has you covered!

    Jetpack offers a foundation for innovative AI Features

    Mayuri Khinvasara Khabya

    Just as Donovan demonstrated with CameraX for capture, Jetpack Media3 provides a reliable, customizable, and feature-rich solution for playback with ExoPlayer. The AI Samples app builds on this foundation to delight users with helpful and enriching AI-driven additions.

    In today’s rapidly evolving digital landscape, users expect more from their media applications. Simply playing videos is no longer enough. Developers are constantly seeking ways to enhance user experiences and provide deeper engagement. Leveraging the power of Artificial Intelligence (AI), particularly when built upon robust media frameworks like Media3, offers exciting opportunities. Let’s take a look at some of the ways we can transform the way users interact with video content:

      • Empowering Video Understanding: The core idea is to use AI, specifically multimodal models like the Gemini Flash and Pro models, to analyze video content and extract meaningful information. This goes beyond simply playing a video; it’s about understanding what’s in the video and making that information readily accessible to the user.
      • Actionable Insights: The goal is to transform raw video into summaries, insights, and interactive experiences. This allows users to quickly grasp the content of a video and find specific information they need or learn something new!
      • Accessibility and Engagement: AI helps make videos more accessible by providing features like summaries, translations, and descriptions. It also aims to increase user engagement through interactive features.

    A Glimpse into AI-Powered Video Journeys

    The following example demonstrates potential video journies enhanced by artificial intelligence. This sample integrates several components, such as ExoPlayer and Transformer from Media3; the Firebase SDK (leveraging Vertex AI on Android); and Jetpack Compose, ViewModel, and StateFlow. The code will be available soon on Github.

    moving images of examples of AI-powered video journeys

    (Left) Video summarization  
     (Right) Thumbnails timestamps and HDR frame extraction

    There are two experiences in particular that I’d like to highlight:

      • HDR Thumbnails: AI can help identify key moments in the video that could make for good thumbnails. With those timestamps, you can use the new ExperimentalFrameExtractor API from Media3 to extract HDR thumbnails from videos, providing richer visual previews.
      • Text-to-Speech: AI can be used to convert textual information derived from the video into spoken audio, enhancing accessibility. On Android you can also choose to play audio in different languages and dialects thus enhancing personalization for a wider audience.

    Using the right AI solution

    Currently, only cloud models support video inputs, so we went ahead with a cloud-based solution.Iintegrating Firebase in our sample empowers the app to:

      • Generate real-time, concise video summaries automatically.
      • Produce comprehensive content metadata, including chapter markers and relevant hashtags.
      • Facilitate seamless multilingual content translation.

    So how do you actually interact with a video and work with Gemini to process it? First, send your video as an input parameter to your prompt:

    val promptData =
    "Summarize this video in the form of top 3-4 takeaways only. Write in the form of bullet points. Don't assume if you don't know"
    
    val generativeModel = Firebase.vertexAI.generativeModel("gemini-2.0-flash")
    _outputText.value = OutputTextState.Loading
    
    viewModelScope.launch(Dispatchers.IO) {
        try {
            val requestContent = content {
                fileData(videoSource.toString(), "video/mp4")
                text(prompt)
            }
            val outputStringBuilder = StringBuilder()
    
            generativeModel.generateContentStream(requestContent).collect { response ->
                outputStringBuilder.append(response.text)
                _outputText.value = OutputTextState.Success(outputStringBuilder.toString())
            }
    
            _outputText.value = OutputTextState.Success(outputStringBuilder.toString())
    
        } catch (error: Exception) {
            _outputText.value = error.localizedMessage?.let { OutputTextState.Error(it) }
        }
    }
    

    Notice there are two key components here:

      • FileData: This component integrates a video into the query.
      • Prompt: This asks the user what specific assistance they need from AI in relation to the provided video.

    Of course, you can finetune your prompt as per your requirements and get the responses accordingly.

    In conclusion, by harnessing the capabilities of Jetpack Media3 and integrating AI solutions like Gemini through Firebase, you can significantly elevate video experiences on Android. This combination enables advanced features like video summaries, enriched metadata, and seamless multilingual translations, ultimately enhancing accessibility and engagement for users. As these technologies continue to evolve, the potential for creating even more dynamic and intelligent video applications is vast.

    Go above-and-beyond with specialized APIs

    Mozart Louis

    Android 16 introduces the new audio PCM Offload mode which can reduce the power consumption of audio playback in your app, leading to longer playback time and increased user engagement. Eliminating the power anxiety greatly enhances the user experience.

    Oboe is Android’s premiere audio api that developers are able to use to create high performance, low latency audio apps. A new feature is being added to the Android NDK and Android 16 called Native PCM Offload playback.

    Offload playback helps save battery life when playing audio. It works by sending a large chunk of audio to a special part of the device’s hardware (a DSP). This allows the CPU of the device to go into a low-power state while the DSP handles playing the sound. This works with uncompressed audio (like PCM) and compressed audio (like MP3 or AAC), where the DSP also takes care of decoding.

    This can result in significant power saving while playing back audio and is perfect for applications that play audio in the background or while the screen is off (think audiobooks, podcasts, music etc).

    We created the sample app PowerPlay to demonstrate how to implement these features using the latest NDK version, C++ and Jetpack Compose.

    Here are the most important parts!

    First order of business is to assure the device supports audio offload of the file attributes you need. In the example below, we are checking if the device support audio offload of stereo, float PCM file with a sample rate of 48000Hz.

           val format = AudioFormat.Builder()
                .setEncoding(AudioFormat.ENCODING_PCM_FLOAT)
                .setSampleRate(48000)
                .setChannelMask(AudioFormat.CHANNEL_OUT_STEREO)
                .build()
    
            val attributes =
                AudioAttributes.Builder()
                    .setContentType(AudioAttributes.CONTENT_TYPE_MUSIC)
                    .setUsage(AudioAttributes.USAGE_MEDIA)
                    .build()
           
            val isOffloadSupported = 
                if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) {
                    AudioManager.isOffloadedPlaybackSupported(format, attributes)
                } else {
                    false
                }
    
            if (isOffloadSupported) {
                player.initializeAudio(PerformanceMode::POWER_SAVING_OFFLOADED)
            }
    

    Once we know the device supports audio offload, we can confidently set the Oboe audio streams’ performance mode to the new performance mode option, PerformanceMode::POWER_SAVING_OFFLOADED.

    // Create an audio stream
            AudioStreamBuilder builder;
            builder.setChannelCount(mChannelCount);
            builder.setDataCallback(mDataCallback);
            builder.setFormat(AudioFormat::Float);
            builder.setSampleRate(48000);
    
            builder.setErrorCallback(mErrorCallback);
            builder.setPresentationCallback(mPresentationCallback);
            builder.setPerformanceMode(PerformanceMode::POWER_SAVING_OFFLOADED);
            builder.setFramesPerDataCallback(128);
            builder.setSharingMode(SharingMode::Exclusive);
               builder.setSampleRateConversionQuality(SampleRateConversionQuality::Medium);
            Result result = builder.openStream(mAudioStream);
    

    Now when audio is played back, it will be offloading audio to the DSP, helping save power when playing back audio.

    There is more to this feature that will be covered in a future blog post, fully detailing out all of the new available APIs that will help you optimize your audio playback experience!

    What’s next

    Of course, we were only able to share the tip of the iceberg with you here, so to dive deeper into the samples, check out the following links:

    Hopefully these examples have inspired you to explore what new and fascinating experiences you can build on Android. Tune in to our session at Google I/O in a couple weeks to learn even more about use-cases supported by solutions like Jetpack CameraX and Jetpack Media3!



    Source link

  • Spotify announces meaningful new features for all users

    Spotify announces meaningful new features for all users


    Spotify stock photo 1

    Edgar Cervantes / Android Authority

    TL;DR

    • Spotify has rolled out new features for both Premium and free users.
    • Premium users get a revamped Queue, a more powerful Hide button, and a new 30-day Snooze feature.
    • Meanwhile, the Spotify app now surfaces new “Add,” “Sort,” and “Edit” tools at the top of playlists.
    • There’s also a new Create button for quick access to several features.

    Spotify has just rolled out a series of meaningful updates aimed at giving users, both Premium and free, greater control over their listening experience. These updates, some of which are still experimental, enhance playlist management, track selection, and social collaboration.

    What’s new for Spotify Premium users?

    Spotify Premium subscribers are getting several upgraded tools, starting with a revamped Queue. Located via the three lines at the bottom of the Now Playing screen, the updated Queue now includes new controls like Shuffle, Smart Shuffle (which suggests personalized tracks), Repeat, and Sleep Timer. Spotify will also show you suggested songs after your queued tracks, helping you decide what to listen to next. If you’d rather not see these suggestions, you have the option of disabling them by turning off Autoplay and Smart Shuffle.

    Another enhancement for Premium users is a more powerful Hide button. Tapping it now removes a song from that playlist across all your devices. If you’d prefer a temporary break from a track, Spotify is also testing a new “30-day Snooze” feature. This experimental option removes the song from your recommendations for a month and may roll out to all users in the future.

    New features for all Spotify users

    In addition to Premium-specific updates, Spotify is introducing broader improvements across its app. All users will now see new “Add,” “Sort,” and “Edit” tools at the top of their playlists. These tools make it easier to customize tracklists, change playlist titles, design custom cover art, and reorder songs to your liking.

    In selected countries, including the US, you can now turn your Liked Songs into a playlist. Simply filter them by genre and tap “Turn into playlist.”

    The mobile app is also getting a new Create button (+) in the bottom-right corner. This gives all users quick access to playlist creation, collaboration features, and Spotify’s social listening tool, Blend. Premium subscribers get bonus features here, including direct access to Jam for real-time group listening and AI Playlist, which builds playlists with the help of AI.

    Lastly, Spotify has slightly reorganized its navigation. Your Library now appears as the third tab at the bottom of the screen.



    Source link

  • Garmin users should start bracing for more subscription-only features

    Garmin users should start bracing for more subscription-only features


    Garmin Connect Plus dashboard

    Ryan Haines / Android Authority

    TL;DR

    • Garmin recently conducted an earnings call for the first quarter of 2025.
    • In the earnings call, CEO Cliff Pemble explains why the company decided to launch Connect Plus.
    • Pemble also mentions reserving features for the subscription service.

    Since the launch of Connect Plus in March, Garmin users have been worried about the future of their devices. These users aren’t just upset about the mere introduction of a subscription service; there’s a palpable concern about what this paywall could mean for new features going forward. A recent earnings call appears to show that there may be some substance behind these fears.

    Garmin recently conducted an earnings call for the first quarter of 2025. During this call, the company announced an 11% improvement year on year, netting earnings of $1.54 billion. On top of that, Garmin reached a record $330 million in operating income. Around the 16:30 minute mark, the call was opened up for questions.

    When asked about the launch of Connect Plus and why the decision was made, CEO Cliff Pemble stated:

    I think we’ve been saying for a while that we are evaluating opportunities to have a premium offering on Garmin Connect. I think the developments of AI and particularly around AI-based insights for our users was one of those things that we felt was important to recognize the value for the investment that it takes to do.

    Pemble went on to mention that the company “felt like it was the right time” and added that they have not taken away any previously free features. Although the smartwatch maker may not have any plans to take away previously free features, Pemble seemed to confirm what users have been worrying about over the last few weeks.

    While discussing the various features Garmin offers, Pemble says “certain ones, we will likely reserve for premium offerings.” Meaning that the company may focus on making Connect Plus a more robust offering by working on features that will be hidden behind the subscription.

    Considering that one of the biggest complaints about Connect Plus is how underwhelming it is, Garmin wanting to build out its service doesn’t come as a big surprise. Unfortunately, if Connect Plus is to become a service worthy of a subscription, such a move is necessary. However, knowing this doesn’t exactly ease the sting that comes with realizing more and more features may become exclusive to Connect Plus.

    Got a tip? Talk to us! Email our staff at news@androidauthority.com. You can stay anonymous or get credit for the info, it’s your choice.



    Source link

  • Android Studio Meerkat Feature Drop is stable



    Posted by Adarsh Fernando, Group Product Manager

    Today, we’re excited to announce the stable release of Android Studio Meerkat Feature Drop (2024.3.2)!

    This release brings a host of new features and improvements designed to boost your productivity and enhance your development workflow. With numerous enhancements, this latest release helps you build high-quality Android apps faster and more efficiently: streamlined Jetpack Compose previews, new Gemini capabilities, better Kotlin Multiplatform (KMP) integration, improved device management, and more.

    Read on to learn about the key updates in Android Studio Meerkat Feature Drop, and download the latest stable version today to explore them yourself!

    Developer Productivity Enhancements

    Analyze Crash Reports with Gemini in Android Studio

    Debugging production crashes can require you to spend significant time switching contexts between your crash reporting tool, such as Firebase Crashlytics and Android Vitals, and investigating root causes in the IDE. Now, when viewing reports in App Quality Insights (AQI), click the Insights tab. Gemini provides a summary of the crash, generates insights, and links to useful documentation. If you also provide Gemini with access to local code context, it can provide more accurate results, relevant next steps, and code suggestions. This helps you reduce the time spent diagnosing and resolving issues.

    moving image of Gemini in the App Quality Insights tool window in Android Studio

    Gemini helps you investigate, understand, and resolve crashes in your app much more quickly in the App Quality Insights tool window.

    Generate Unit Test Scenarios with Gemini

    Writing effective unit tests is crucial but can be time-consuming. Gemini now helps kickstart this process by generating relevant test scenarios. Right-click on a class in your editor and select Gemini > Generate Unit Test Scenarios. Gemini analyzes the code and suggests test cases with descriptive names, outlining what to test. While you still implement the specific test logic, this significantly speeds up the initial setup and ensures better test coverage by suggesting scenarios you might have missed.

    moving image of generating unit test scenarios in Android Studio

    Gemini helps you generate unit test scenarios for your app.

    Gemini Prompt Library

    No more retyping your most frequently used prompts for Gemini! The new Prompt Library lets you save prompts directly within Android Studio (Settings > Gemini > Prompt Library). Whether it’s a specific code generation pattern, a refactoring instruction, or a debugging query you use often, save it once from the chat (right-click > Save prompt) and re-apply it instantly from the editor (right-click > Gemini > Prompt Library). Prompts that you save can also be shared and standardized across your team.

    moving image of prompt library in Android Studio

    The prompt library saves your frequently used Gemini prompts to make them easier to use.

    You have the option to store prompts on IDE level or Project level:

      • IDE level prompts are private and can be used across multiple projects.
      • Project level prompts can be shared across teams working on the same project (if .idea folder is added to VCS).

    Compose and UI Development

    Themed Icon Support Preview

    Ensure your app’s branding looks great with Android’s themed icons. Android Studio now lets you preview how your existing launcher icon adapts to the monochromatic theming algorithm directly within the IDE. This quick visual check helps you identify potential contrast issues or undesirable shapes early in the workflow, even before you provide a dedicated monochromatic drawable. This allows for faster iteration on your app’s visual identity.

    moving image of themed icon support in preview in Android Studio

    Themed icon support in Preview helps you visually check how your existing launcher icon adapts to monochromatic theming.

    Compose Preview Enhancements

    Iterating on your Compose UI is now faster and better organized:

      • Enhanced Zoom: Navigate complex layouts more easily with smoother, more responsive zooming in your Compose previews.
      • Collapsible Groups: Tidy up your preview surface by collapsing groups of related composables under their @Preview annotation names, letting you focus on specific parts of the UI without clutter.
      • Grid Mode by Default: Grid mode is now the default for a clear overview. Gallery mode (for flipping through individual previews) is available via right-click, while List view has been removed to streamline the experience.

    moving image of Compose previews in Android Studio

    Compose previews render more smoothly and make it easier to hide previews you’re not focused on.

    Build and Deploy

    KMP Shared Module Integration

    Android Studio now streamlines adding shared logic to your Android app with the new Kotlin Multiplatform Shared Module template. This provides a dedicated starting point within your Android project, making it easier to structure and build shared business logic for both Android and iOS directly from Android Studio.

    Kotlin Multiplatform template in Android Studio

    The new Kotlin Multiplatform module template makes it easier to add shared business logic to your existing app.

    Updated UX for Adding Devices

    Spend less time configuring test devices. The new Device Manager UX for adding virtual and remote devices makes it much easier to configure the devices you want from the Device Manager. To get started, click the ‘+’ action at the top of the window and select one of these options:

      • Create Virtual Device: New filters, recommendations, and creation flow guide you towards creating AVDs that are best suited for your intended purpose and your machine’s performance.
      • Add Remote Devices: With Android Device Streaming, powered by Firebase, you can connect and debug your app with a variety of real physical devices. With a new catalog view and filters, it’s now easier to locate and start using the device you need in just a few clicks.

    moving image of configuring virtual devices in Android Studio

    It’s now easier to configure virtual devices that are optimized for your workstation.

    Google Play Deprecated SDK Warnings

    Stay more informed about SDKs you publish with your app. Android Studio now displays warnings from the Google Play SDK Index when an SDK used in your app has been deprecated by its author. These warnings include information about suggested alternative SDKs, helping you proactively manage dependencies and avoid potential issues related to outdated or insecure libraries.

    Google Play Deprecated SDK warnings in Android Studio

    Play deprecated SDK warnings help you avoid potential issues related to outdated or insecure libraries.

    Updated Build Menu and Actions

    We’ve refined the Build menu for a more intuitive experience:

      • New ‘Build run-configuration-name’ Action: Builds the currently selected run configuration (e.g., :app or a specific test). This is now the default action for the toolbar button and Control/Command+F9.
      • Reordered Actions: The new build action is prioritized at the top, followed by Compile and Assemble actions.
      • Clearer Naming: “Rebuild Project” is now “Clean and Assemble Project with Tests”. “Make Project” is renamed to “Assemble Project”, and a new “Assemble Project with Tests” action is available.

    Build menu in Android Studio

    The Build menu includes behavior and naming changes to simplify and streamline the experience.

    Standardized Config Directories

    Switching between Stable, Beta, and Canary versions of Android Studio is now smoother. Configuration directories are standardized, removing the “Preview” suffix for non-stable builds. We’ve also added the micro version (e.g., AndroidStudio2024.3.2) to the path, allowing different feature drops to run side-by-side without conflicts. This simplifies managing your IDE settings, especially if you work with multiple Android Studio installations.

    IntelliJ platform update

    Android Studio Meerkat Feature Drop (2024.3.2) includes the IntelliJ 2024.3 platform release, which has many new features such as a feature complete K2 mode, more reliable Java** and Kotlin code inspections, grammar checks during indexing, debugger improvements, speed and quality of life improvements to Terminal, and more.

    For more information, read the full IntelliJ 2024.3 release notes.

    Summary

    Android Studio Meerkat Feature Drop (2024.3.2) delivers these key features and enhancements:

      • Developer Productivity:
          • Analyze Crash Reports with Gemini
          • Generate Unit Test Scenarios with Gemini
          • Gemini Prompt Library
      • Compose and UI:
          • Themed Icon Preview
          • Compose Preview Enhancements (Zoom, Collapsible Groups, View Modes)
      • Build and Deploy:
          • KMP Shared Module Template
          • Updated UX for Adding Devices
          • Google Play SDK Insights: Deprecated SDK Warnings
          • Updated Build Menu & Actions
          • Standardized Config Directories
      • IntelliJ Platform Update
          • Feature complete K2 mode
          • Improved Kotlin and Java** inspection reliability
          • Debugger improvements
          • Speed and quality of life improvements in Terminal

    Getting Started

    Ready to elevate your Android development? Download Android Studio Meerkat Feature Drop and start using these powerful new features today!

    As always, your feedback is crucial. Check known issues, report bugs, suggest improvements, and connect with the community on LinkedIn, Medium, YouTube, or X. Let’s continue building amazing Android apps together!

    **Java is a trademark or registered trademark of Oracle and/or its affiliates.





    Source link

  • There’s good and bad news about the Z Fold and Flip 7 batteries- Android Authority

    There’s good and bad news about the Z Fold and Flip 7 batteries- Android Authority


    The Samsung Galaxy Z Flip 6 and Z Fold 6 on a table.

    Hadlee Simons / Android Authority

    TL;DR

    • The batteries for the Galaxy Z Fold 7 and Galaxy Z Flip 7 have received UL Demko certification.
    • The Z Fold 7 would have a total battery capacity of 4,272mAh, while the Z Flip 7 gets 4,174mAh.
    • Both devices may have 25W wireless charging speeds, up from the 15W of previous generations.

    As we get closer to summer, Samsung’s next generation of foldables is looming just over the horizon. We’re anticipating Samsung’s next Galaxy Unpacked event in the first half of July, which may be held in New York for the first time in three years. Here, we should see the Galaxy Z Fold 7 and Z Flip 7 devices, and leaks continue to give us a good idea of what to expect.

    What appear to be the batteries for both the Galaxy Z Fold 7 and Z Flip 7 have received UL Demko certification, which follows their earlier BIS certification, according to TheTechOutlook. Because of this, we now have some solid expectations for the capacities of both batteries.

    For the Galaxy Z Fold 7, we’re looking at possible battery model numbers of EB-BF966ABE and EB-BF967ABE, while these got certificate numbers of DK–163799-UL and DK–163657-UL. These are Li-ion batteries with capacities of 2,126mAh and 2,146mAh, which means 4,272mAh total for the rated capacity. As a comparison, the Galaxy Z Fold 6 packs in 2,355mAh and 1,918mAH batteries, which brings its rated total to 4,273mAh. In terms of marketing, since the Z Fold 6 has a typical 4,400mAh capacity, we should expect something similar for the Z Fold 7 as well.

    Regarding the Z Flip 7, we’ve got model numbers EB-BF766ABE and EB-BF767ABE for the potential batteries here, with certification numbers DK–163399-UL and DK–163928-UL. On this one, the capacities of the batteries are 1,189mAh and 2,985mAh, which would be a total of 4,174mAh. For reference, the Galaxy Z Flip 6’s components were rated at 2,790mAh and 1,097mAh, which is a total of 3,887mAh capacity. The typical capacity for the Z Flip 6 is 4,000mAh, so Samsung may be thinking of positioning this be as 4,300mAh for the Z Flip 7.

    From these new certification listings, those who prefer the larger Galaxy Z Fold series could  see a negligible drop in battery capacity, while the Z Flip fans are likely due a more substantial increase. Of course, actual battery life depends on what you do with your device all day, so these numbers may or may not have a big impact. We’ll find out when the phones launch and we try them out ourselves.

    But there is some good news for both, thankfully. It appears the the next-generation of foldables should support 25W wireless charging, according to their listings in China’s 3C certification database as spotted by TheTechOutlook. However, we also saw that both the Z Fold 7 and Flip 7 might only have 25W wired charging speeds as well, which isn’t as impressive as some of Samsung’s other flagships, and even mid-range devices with 45W.

    We also expect the Galaxy Z Fold 7 and Flip 7 to have Snapdragon 8 Elite SoC and at least 12GB RAM. With just a couple more months before the release of Samsung’s next-generation foldables, we shouldn’t have a much longer wait and will likely see plenty more leaks in the coming weeks.

    Got a tip? Talk to us! Email our staff at news@androidauthority.com. You can stay anonymous or get credit for the info, it’s your choice.



    Source link