Android Geliştirme

// Değişken tanımlama
val name = "Android"        // Değiştirilemez (immutable)
var version = 15           // Değiştirilebilir (mutable)

// Null güvenliği
var nullableString: String? = null
val length = nullableString?.length ?: 0

// Fonksiyon tanımlama
fun greetUser(name: String): String {
    return "Merhaba, $name!"
}

// Tek satır fonksiyon
fun add(a: Int, b: Int) = a + b

// Data class otomatik olarak equals, hashCode, toString üretir
data class User(
    val id: String,
    val name: String,
    val email: String
)

// Kullanımı
val user = User("1", "Ahmet Yılmaz", "ahmet@example.com")
println(user.name) // Çıktı: Ahmet Yılmaz

// Coroutine kullanımı
import kotlinx.coroutines.*

fun main() {
    runBlocking {
        launch {
            delay(1000L)
            println("Dünya!")
        }
        println("Merhaba,")
    }
}

class MainActivity : AppCompatActivity() {
    
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)
        // UI bileşenlerini başlat
    }
    
    override fun onStart() {
        super.onStart()
        // Activity görünür hale geldiğinde
    }
    
    override fun onResume() {
        super.onResume()
        // Kullanıcı etkileşimi başladığında
    }
    
    override fun onPause() {
        super.onPause()
        // Activity duraklatıldığında
    }
    
    override fun onDestroy() {
        super.onDestroy()
        // Activity yok edildiğinde - temizlik işlemleri
    }
}

class HomeFragment : Fragment() {
    
    override fun onCreateView(
        inflater: LayoutInflater,
        container: ViewGroup?,
        savedInstanceState: Bundle?
    ): View? {
        return inflater.inflate(R.layout.fragment_home, container, false)
    }
    
    override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
        super.onViewCreated(view, savedInstanceState)
        // View bileşenlerini yapılandır
    }
}

@Composable
fun Greeting(name: String) {
    Text(
        text = "Merhaba, $name!",
        modifier = Modifier.padding(16.dp),
        style = MaterialTheme.typography.headlineMedium
    )
}

@Composable
fun UserCard(user: User) {
    Card(
        modifier = Modifier
            .fillMaxWidth()
            .padding(8.dp),
        elevation = CardDefaults.cardElevation(defaultElevation = 4.dp)
    ) {
        Column(
            modifier = Modifier.padding(16.dp)
        ) {
            Text(
                text = user.name,
                style = MaterialTheme.typography.titleMedium
            )
            Text(
                text = user.email,
                style = MaterialTheme.typography.bodyMedium,
                color = MaterialTheme.colorScheme.onSurfaceVariant
            )
        }
    }
}

@Composable
fun Counter() {
    var count by remember { mutableStateOf(0) }
    
    Column(
        horizontalAlignment = Alignment.CenterHorizontally,
        modifier = Modifier.padding(16.dp)
    ) {
        Text(
            text = "Sayaç: $count",
            style = MaterialTheme.typography.headlineMedium
        )
        
        Button(
            onClick = { count++ },
            modifier = Modifier.padding(top = 8.dp)
        ) {
            Text("Artır")
        }
    }
}

// Entity (Veri modeli)
@Entity(tableName = "users")
data class User(
    @PrimaryKey val id: String,
    val name: String,
    val email: String,
    val createdAt: Long = System.currentTimeMillis()
)

// DAO (Data Access Object)
@Dao
interface UserDao {
    
    @Query("SELECT * FROM users ORDER BY createdAt DESC")
    fun getAllUsers(): Flow<List<User>>
    
    @Insert(onConflict = OnConflictStrategy.REPLACE)
    suspend fun insertUser(user: User)
    
    @Delete
    suspend fun deleteUser(user: User)
    
    @Query("SELECT * FROM users WHERE name LIKE :searchQuery")
    fun searchUsers(searchQuery: String): Flow<List<User>>
}

// Database sınıfı
@Database(
    entities = [User::class],
    version = 1,
    exportSchema = false
)
@TypeConverters(Converters::class)
abstract class AppDatabase : RoomDatabase() {
    
    abstract fun userDao(): UserDao
    
    companion object {
        @Volatile
        private var INSTANCE: AppDatabase? = null
        
        fun getDatabase(context: Context): AppDatabase {
            return INSTANCE ?: synchronized(this) {
                val instance = Room.databaseBuilder(
                    context.applicationContext,
                    AppDatabase::class.java,
                    "app_database"
                ).build()
                INSTANCE = instance
                instance
            }
        }
    }
}

// Repository sınıfı örneği
class UserRepository(
    private val userDao: UserDao
) {
    fun getAllUsers(): Flow<List<User>> = userDao.getAllUsers()
    
    suspend fun insertUser(user: User) {
        userDao.insertUser(user)
    }
    
    suspend fun deleteUser(user: User) {
        userDao.deleteUser(user)
    }
}

// API interface tanımı
interface ApiService {
    
    @GET("users")
    suspend fun getUsers(): Response<List<User>>
    
    @GET("users/{id}")
    suspend fun getUserById(
        @Path("id") userId: String
    ): Response<User>
    
    @POST("users")
    suspend fun createUser(
        @Body user: CreateUserRequest
    ): Response<User>
    
    @PUT("users/{id}")
    suspend fun updateUser(
        @Path("id") userId: String,
        @Body user: UpdateUserRequest
    ): Response<User>
}

// Retrofit instance oluşturma
object ApiClient {
    private const val BASE_URL = "https://api.example.com/"
    
    private val okHttpClient = OkHttpClient.Builder()
        .addInterceptor(HttpLoggingInterceptor().apply {
            level = HttpLoggingInterceptor.Level.BODY
        })
        .addInterceptor { chain ->
            val request = chain.request().newBuilder()
                .addHeader("Authorization", "Bearer your-token")
                .build()
            chain.proceed(request)
        }
        .connectTimeout(30, TimeUnit.SECONDS)
        .readTimeout(30, TimeUnit.SECONDS)
        .build()
    
    val apiService: ApiService by lazy {
        Retrofit.Builder()
            .baseUrl(BASE_URL)
            .client(okHttpClient)
            .addConverterFactory(GsonConverterFactory.create())
            .build()
            .create(ApiService::class.java)
    }
}

// Repository'de network çağrısı
class UserRepository(
    private val apiService: ApiService,
    private val userDao: UserDao
) {
    suspend fun getUsers(): Resource<List<User>> {
        return try {
            val response = apiService.getUsers()
            if (response.isSuccessful) {
                response.body()?.let { users ->
                    userDao.insertUsers(users)
                    Resource.Success(users)
                } ?: Resource.Error("Veri bulunamadı")
            } else {
                Resource.Error("Sunucu hatası: ${response.code()}")
            }
        } catch (e: Exception) {
            Resource.Error(e.message ?: "Bilinmeyen hata")
        }
    }
}

// Unit Test örneği
@Test
fun userRepository_insertsUser_successfully() = runTest {
    // Arrange
    val user = User("1", "John Doe", "john@example.com")
    
    // Act
    repository.insertUser(user)
    val result = repository.getAllUsers().first()
    
    // Assert
    assertThat(result).contains(user)
    assertThat(result.size).isEqualTo(1)
}

@Test
fun emailValidator_validEmail_returnsTrue() {
    // Arrange
    val email = "test@example.com"
    
    // Act
    val result = EmailValidator.isValid(email)
    
    // Assert
    assertThat(result).isTrue()
}

// UI Test (Espresso) örneği
@RunWith(AndroidJUnit4::class)
class MainActivityTest {
    
    @get:Rule
    val activityRule = ActivityScenarioRule(MainActivity::class.java)
    
    @Test
    fun clickButton_displaysCorrectText() {
        // Düğmeye tıkla
        onView(withId(R.id.button))
            .perform(click())
        
        // Sonucu doğrula
        onView(withId(R.id.textView))
            .check(matches(withText("Merhaba!")))
    }
}

// Compose UI Test örneği
@Test
fun userCard_displaysCorrectInformation() {
    composeTestRule.setContent {
        UserCard(user = User("1", "John", "john@test.com"))
    }
    
    composeTestRule
        .onNodeWithText("John")
        .assertIsDisplayed()
    
    composeTestRule
        .onNodeWithText("john@test.com")
        .assertIsDisplayed()
}

// Memory leak'i önleme - WeakReference kullanımı
class MyAsyncTask(private val activityRef: WeakReference<Activity>) {
    
    fun doBackgroundWork() {
        // Arka plan işlemleri
        GlobalScope.launch(Dispatchers.IO) {
            val result = performNetworkCall()
            
            withContext(Dispatchers.Main) {
                activityRef.get()?.let { activity ->
                    // UI güncelleme - Activity hala alive ise
                    updateUI(result)
                }
            }
        }
    }
}

// Kullanımı
val task = MyAsyncTask(WeakReference(this))

// Efficient image loading with Glide
Glide.with(context)
    .load(imageUrl)
    .placeholder(R.drawable.placeholder)
    .error(R.drawable.error_image)
    .diskCacheStrategy(DiskCacheStrategy.ALL)
    .transform(CenterCrop(), RoundedCorners(16))
    .into(imageView)

// RecyclerView optimizasyonu
class UserAdapter : RecyclerView.Adapter<UserViewHolder>() {
    
    init {
        setHasStableIds(true) // Performance için
    }
    
    override fun getItemId(position: Int): Long {
        return users[position].id.hashCode().toLong()
    }
}

// Compose performans optimizasyonu
@Composable
fun UserList(users: List<User>) {
    LazyColumn {
        items(
            items = users,
            key = { user -> user.id } // Performance için önemli
        ) { user ->
            UserItem(
                user = user,
                onClick = remember { { onUserClick(user.id) } }
            )
        }
    }
}

@Stable
data class User(
    val id: String,
    val name: String,
    val email: String
)

// Terminal komutları - AAB oluşturma

# Debug AAB
./gradlew bundleDebug

# Release AAB
./gradlew bundleRelease

# APK'dan AAB test etme
java -jar bundletool.jar build-apks \
  --bundle=app-release.aab \
  --output=app.apks \
  --ks=keystore.jks \
  --ks-pass=pass:your_password \
  --ks-key-alias=your_alias \
  --key-pass=pass:your_key_password

# Cihaza yükleme
java -jar bundletool.jar install-apks --apks=app.apks