Google wants developers to build Android apps faster while making sure quality isn’t sacrificed for speed. In the current AI era, where thousands of AI models claim to be the best for coding, it’s actually difficult to know which ones truly perform well for Android development.

That’s where Android Bench comes in.

Android Bench is a benchmarking framework that evaluates an AI model’s ability to:

• Understand mobile codebases
• Generate accurate patches
• Solve Android-specific engineering problems

The benchmark includes challenges that replicate real problems developers face during everyday development. It consists of 100 tasks selected from a pool of 38,989 pull requests, which makes the evaluation much closer to real-world scenarios.

This is actually a smart approach for both companies and developers. It helps them decide which AI model is worth investing in, ensuring a higher return on investment (ROI).

Kirill Smelov, Head of AI Integrations at JetBrains, also commented on this:

“Measuring AI’s impact on Android is a massive challenge, so it’s great to see a framework that’s this sound and realistic. While we’re active in benchmarking ourselves, Android Bench is a unique and welcome addition. This methodology is exactly the kind of rigorous evaluation Android developers need right now.”

Kirill Smelov

First Android Bench Results

The first results clearly show which models currently perform best. According to the benchmark:

1. Gemini 3.1 Pro Preview ranks first
2. Claude comes second
3. GPT‑5.2 follows in third place

These benchmarks could become very useful for developers trying to decide which AI model to use in their workflow.

Personally, I believe Android Bench will play an important role in helping teams choose the right AI tools for Android development.

Let's start to enable automatic per-app language support

1-Make sure that the generateLocaleConfig is true as it is false by default

by adding this in your build.gradle.kts.

android {
      androidResources {
        generateLocaleConfig = true
      }
    }

2-Create new file and name it resources.properties and add it inside your res package

2-here we will declare our app supported language Create a file called res/xml/locales_config.xml

and add your supported languages inside it

<?xml version="1.0" encoding="utf-8"?>
<locale-config xmlns:android="http://schemas.android.com/apk/res/android">
   <locale android:name="en-US"/>
   <locale android:name="en-GB"/>
   <locale android:name="fr"/>
   <locale android:name="ja"/>
   <locale android:name="zh-Hans-MO"/>
   <locale android:name="zh-Hant-MO"/>
</locale-config>

then inside your manifest file make sure that you have pointed to this file.

<manifest>
    ...
    <application
        ...
        android:localeConfig="@xml/locales_config">
    </application>
</manifest>

Congrats now the user will find the language you supports inside your application settings.

Next Article it will be about how to create lanugae picker with latest updates.

You can follow me on X also Github and Linkedin.

If you’ve been working with Android development for a while, you’ve probably heard the term design patterns being thrown around. They might sound like something complex, but in reality, they’re just tried-and-tested solutions to common coding problems. Think of them as blueprints for writing cleaner, more maintainable, and scalable code.

In this article, we’ll break down some of the most useful design patterns in Android development, why they matter, and how you can apply them in real-world projects.

1. Singleton Pattern — The One and Only

Imagine you have a database instance, a network client, or a shared preferences manager in your app. You don’t want multiple instances of these floating around, eating up memory and causing inconsistencies. That’s where the Singleton Pattern comes in.

How It Works:

It ensures that only one instance of a class exists and provides a global access point to it.

Implementation:

object DatabaseHelper {
    fun getConnection(): String {
        return "Database Connected"
    }
}

Here, DatabaseHelper is a singleton, meaning the same instance will be used throughout the app. Simple, yet powerful!

2. Factory Pattern — Smart Object Creation

Sometimes, creating objects the usual way (new keyword or constructor) isn’t flexible enough. The Factory Pattern lets you create objects without specifying the exact class type beforehand.

Example:

Let’s say you need different types of buttons in your app.

sealed class Button {
    class PrimaryButton : Button()
    class SecondaryButton : Button()
}

object ButtonFactory {
    fun createButton(type: String): Button {
        return when (type) {
            "primary" -> Button.PrimaryButton()
            "secondary" -> Button.SecondaryButton()
            else -> throw IllegalArgumentException("Unknown button type")
        }
    }
}

Now, you can create buttons dynamically without worrying about their exact type!

3. Observer Pattern — Keeping Things in Sync

Ever used LiveData or Flow in Jetpack Compose? If so, congratulations — you’ve already used the Observer Pattern!

Why It’s Useful:

It helps in situations where one object (the observable) needs to notify multiple objects (the observers) when something changes. This is great for UI updates, data binding, and event-driven programming.

Example:

val liveData = MutableLiveData<String>()

liveData.observe(viewLifecycleOwner) { updatedText ->
    textView.text = updatedText
}

Whenever liveData changes, the observer (in this case, the UI) gets notified and updates accordingly.

4. Dependency Injection (DI) — Keeping It Loose

Manually creating dependencies in every class can lead to tight coupling. DI solves this by injecting dependencies rather than creating them manually.

Example with Hilt (Google’s DI Framework):

@InstallIn(SingletonComponent::class)
@Module
class AppModule {
    @Provides
    fun provideRetrofit(): Retrofit {
        return Retrofit.Builder()
            .baseUrl("https://api.example.com")
            .build()
    }
}

Now, anytime you need a Retrofit instance, you just ask Hilt to inject it—no need to instantiate it manually!

Wrapping Up

Design patterns in Android aren’t just fancy concepts; they solve real-world problems and make your code cleaner, scalable, and maintainable. By mastering these patterns, you’ll write better code, debug faster, and build more efficient apps.

So next time you’re coding, take a moment to ask: Can I apply a design pattern here? Chances are, the answer is yes!

Happy coding! 🚀

You can follow me on X , LinkedIn and Github for more like Articles !

Introduction 📝

As a contributor to Detekt, I have firsthand experience with how this tool helps improve Kotlin code quality. In modern software development, maintaining high code quality is essential for building scalable and maintainable applications. Static code analysis tools help developers detect issues early in the development process, reducing technical debt and improving overall efficiency. For Kotlin developers, Detekt is a powerful tool designed specifically to analyze and enforce best practices in Kotlin codebases.

What is Detekt? 🔍

Detekt is a static code analysis tool for Kotlin that helps developers identify code smells, enforce coding standards, and automate code reviews. It provides comprehensive reports highlighting potential issues such as complex functions, long parameter lists, unused imports, and redundant code. Compared to other tools like Android Lint and SonarQube, Detekt is specifically optimized for Kotlin and offers extensive customization options.

Why Use Detekt? ✅

Using Detekt for Kotlin static analysis brings several advantages:

• 🛑 Detect Code Smells — Identifies problematic areas like long methods, high cyclomatic complexity, and unused code.
• 📏 Ensures Coding Standards — Helps maintain consistency across a codebase by enforcing Kotlin best practices.
• 🤖 Automates Code Reviews — Acts as an automated code reviewer, flagging issues before code is merged.
• 🔄 Integrates with CI/CD Pipelines — Works seamlessly with tools like GitHub Actions, Jenkins, and GitLab CI/CD to maintain code quality across deployments.
• ⚙️ Customizable Rule Set — Developers can customize Detekt rules to fit their project’s needs, enabling flexibility in enforcing standards.

How to Set Up Detekt in a Kotlin Project 🛠️

Adding Detekt to a Kotlin project is straightforward. Follow these steps:

1. 📌 Add Detekt to Gradle

plugins {id("io.gitlab.arturbosch.detekt") version "1.23.0" }

2. 🚀 Run Detekt Analysis Execute the following command to analyze your project:

./gradlew detekt

3. 📊 Review the Generated Report Detekt generates an HTML or XML report detailing the issues found in the code.

Customizing Detekt Rules 🎯

Detekt allows customizing rules to match project-specific requirements:

1. 🛠️ Generate a Default Configuration File

./gradlew detektGenerateConfig

2. ⚙️ Modify detekt.yml to Adjust Rules

• ❌ Disable unwanted rules
• 📏 Adjust thresholds for complexity metrics
• 🔍 Enable additional checks for stricter validation

Example:

complex-methods:
  active: true
  threshold: 15

Conclusion 🎉

Stay tuned for Part Two, where I will provide a hands-on example of using Detekt in a Kotlin project! Detekt for Kotlin is an essential tool for developers aiming to improve code quality, enforce best practices, and automate static analysis. By integrating Detekt into your Kotlin development workflow, you can reduce technical debt, enhance maintainability, and ensure high standards in your Kotlin projects. Start using Detekt today to make your Kotlin code cleaner and more efficient! 🚀

Follow on github and LinkedIn for more !

واحدة من المكتبات المهمة جداً ليك كمبرمج نيتف هي روم — Room Database

وهي المسؤلة عن storage عندك في الابب

أمتي تستخدمها

لما تكون محتاج تحفظ داتا كتيرة وكبيرة عندك في الابليكشن علي عكس ال Sharedprefrences

تستخدمها فقط لما تعوز تحفظ معلومات او بيانات اساسية ورئيسية

او تحديداً (“تفضيلات المستخدم”) سواء هو بيحب اللايت مود ولا الدارك مود طب هو بيحب انهي لغة اكتر الحاجات دي بنستخدم معاها شيرد بريفرنسز ولكن لو هحفظ مثلاً list<items>يبقا انا كدا هستخدم روم

روم تعتبر الحد الفاصل بينك وبين sqllite database وبتسهل عليك الموضوع جداً

عشان تطبقها او تستخدمها لازم يكون عندك 3 مكونات رئيسية

1-Entity : ودي بتبقا المودل كلاس الي بنعملوه زي الداتا الي جايلنا زي مثلاً

وبنعلن عنه بأنوتشن فوق الكلاس بيكتب كدا Entity@ بيبقا مكان table database

2-DAO ودا بيبقا انترفيس فيه الميثودز الي بيتم استخدامها زي مثلاًة انك تضيف اوبجيكت او تمسح او تختار عناصر معينة من ال entity بتاعتك

3-Database class ودا الكلاس الي بيأكسس ال entities عن طريق ال DAO

الرسمة الي تحت بتشرح الروم شغالة ازاي ولو ركزت شوية هتلاقي ان تطبيق الروم شبه تطبيق الريتروفيت

يتبع لو عجب الناس

For me, it is the most dangerous line of code on any project codebase,

I will tell you why you are literally by setting exported = true you are giving a backdoor to any hacker to reverse engineer your app it actually can access any activity with this flag = true so let`s get started and learn what it mean.

You of course know that Android has main 4 components :

• Activities
• Services
• Broadcast receivers
• Content providers

This time we will focus on Broadcast receivers in nutshell it is if any other app or the system want to talk to your project you need to use broadcast receivers and to enable receiving these events you should set the exported flag with true .

So when any hacker decompile your apk he will sea the Manifest then he can know which activity is used for this component.

Then He can open any activity directly with out the need to process the normal flow of the app so let`s check some code.

<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:tools="http://schemas.android.com/tools">

    <uses-feature
        android:name="android.hardware.camera"
        android:required="false" />

    <uses-permission android:name="android.permission.INTERNET" />
    <uses-permission android:name="android.permission.POST_NOTIFICATIONS" />
    <uses-permission android:name="android.permission.CAMERA" />

    <uses-permission android:name="android.permission.VIBRATE" />

    <application
        android:name=".core.BankingApp"
        android:allowBackup="true"
        android:dataExtractionRules="@xml/data_extraction_rules"
        android:fullBackupContent="@xml/backup_rules"
        android:icon="@mipmap/ic_launcher"
        android:label="@string/app_name"
        android:supportsRtl="true"
        android:theme="@style/Theme.App.Starting"
        tools:targetApi="31">
        <!-- With singleTop avoid reopening from notification -->
        <activity
            android:name=".PinActivity"
            android:exported="false"
            android:launchMode="singleTop">
            <intent-filter>
                <action android:name="android.intent.action.MAIN" />
                <category android:name="android.intent.category.LAUNCHER" />
            </intent-filter>
        </activity>
      <activity
            android:name=".LoginActivity"
            android:exported="false"
            android:launchMode="singleTop">
           
        </activity>
        <activity
            android:name=".TransferActivity"
            android:exported="true"
            android:launchMode="singleTop">
       
        </activity>
        
        <!--  Allow Koin to init WorkManager itself-->
        <provider
            android:name="androidx.startup.InitializationProvider"
            android:authorities="${applicationId}.androidx-startup"
            android:exported="false"
            tools:node="merge">
            <meta-data
                android:name="androidx.work.WorkManagerInitializer"
                android:value="androidx.startup"
                tools:node="remove" />
        </provider>
    </application>

</manifest>

This Manifest file is for a banking project that has 3 activities first two are log in, Pin Activities (Authorization security related) and they are fine exported = false, the third one is money transfer activity which is exported = true for some reason

In the normal flow, the user will log in Enter the pin then do his money transfer securely.

But the hacker can directly open the transfer activity and miss out on it passing values and wrong data and that`s not what we want.

Anyone can do that by passing this command

am start -n com.android.banking/.TransferActivity

It will open the transfer activity directly

How to protect yourself from this vulnerability?

Per documentation :-

Use calls and callbacks

In the case you used broadcast receivers for internal app purposes (ie. event completion notification), you can restructure your code to pass a callback that would fire after event completion instead.

• Just set “android:exported=false” unless you really want your activity to be exported just make sure to limit which apps can access it.

Thanks for reaching here for more articles like that please follow me

Linkedin , Github and Medium

In this article, I will share with you my way to auto-deploy my client's websites from GitHub to Cpanel.

One of the most important practices in the software world is called “CI-CD”

which stands for continuous integration and continuous delivery/deployment, it speeds up delivery time also development time .

let's go to the important part ,

We will upload PHP (Laravel) website directly to the server through ftp account.

First : We need to create FTP account on our Cpanel , Open the cpanel then go to FTP accounts then add username , choose the domain and add the password (and make sure there is no special characters and I will tell you why later😂)

Second : Go to your github repo and then go to Actions sections and choose set up a workflow yourself .

Now we will start writing our own workflow on a YML file which a language to write human-readable data serialization language that is often used for writing configuration files.

we will write this insturctions you will find it on this gist on github

these instructions contains three main parts

First Part : which is about when to do the deployment (Every Push) ,

and what branch to get the code from and we choosed (master)

Second part : to checkout the repo to git the latest updates.

Third part : to sync the code via ftp account .

now commit then wait until the workflow finishes loading .

Congratsssss 💃 🚀 with every push your server will be updated with the latest code base.

I hope you liked the article and it helped you .

you can follow me on github , linked in , twitter and visit my website

How To Deploy Any Project From GitHub to Cpanel (FTP) - Laravel PHP Project was originally published in DevOps.dev on Medium, where people are continuing the conversation by highlighting and responding to this story.

But now while developing the projects using compose we faced muliple issues with localization that we will discuss on this blog :

1-Change Layout Diraction with RTL language (Make it dynamic to switch between RTL , LTR)

2-Using Arabic and other languages strings in compose

for the first part which is changing layout diraction with RTL languages

we will need to use CompositionLocalProvider which provides Local to the compose elements of the tree that we will use to provide the current diraction for the compose elements

first we need to check the current APP language if it RTL or not and if it supports like “arabic” we will asign the rtl layout diraction to it like the sample below

var local = if (LanguageSetting.getLanguage(this).toString()=="ar") LayoutDirection.Rtl else LayoutDirection.Ltr

note : the default is of course LTR

now we will pass the layout diraction we give it to “local” before to the

CompositionLocalProvider.

CompositionLocalProvider(LocalLayoutDirection provides local) {
    Row {
      Text("Test Text", modifier = Modifier.padding(end = 8.dp))
    }
  }

Congrats now your project support RTL languages like (arabic , urdo and herbew) and alot more

Now the second point which is using arabic and other languages

you need to make sure that you change Configuration when the user chooses to chage the languages

i use this setCurrentLanguage function to change the language and it works fine with jetpack compsoe

private fun setCurrentLanguage(){
    val config = resources.configuration
    val locale = java.util.Locale(LanguageSetting.getLanguage(this).toString())
    java.util.Locale.setDefault(locale)
    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.JELLY_BEAN_MR1)
        config.setLocale(locale)
    else
        config.locale = locale

    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.N)
        createConfigurationContext(config)
    resources.updateConfiguration(config, resources.displayMetrics)
}

of course jetpack compose is a great ui tooling but like at the first of any new technology there is Odds we face it but we work on it together .

i hope i have helped you to solve localization issue with compose .

Compose Features

First question comes to any android developer is why to use Compose ? and why to start learning it?

as in google`s documentation they say 4 reasonable reasons and they are meanly about reducing efforts , development time and less code .

also it`s more easier than XML and familiar to the reader of the code

I will tell you the most important reason and it is that compose will be the trend in android . and most of companys will ask developers to learn it as it gives them more power and gives the business less time to market .

How to use Compose?

Compose is Intuitive because it uses declarative API all you need is just to describe the layout you want to draw over your UI , Compose consists of

small, stateless components that are not tied to a specific activity or fragment. which makes reusing it very easy.

Learn Compose or XML ?

I think you must learn both because the are a lot of old projects out there which built in xml , also there will be a lot of projects in Jetpack compose.

So you shouldn’t lose any of them . and you can start learning them in google android developers courses

Conclusion

Jetpack Compose is gaining reputation between android developers also google advises to use it , and also you should now the basics of xml because if you are asked to edit some old legacy xml code base.