<?xml version="1.0" encoding="UTF-8"?><rss xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:content="http://purl.org/rss/1.0/modules/content/" xmlns:atom="http://www.w3.org/2005/Atom" version="2.0" xmlns:cc="http://cyber.law.harvard.edu/rss/creativeCommonsRssModule.html">
    <channel>
        <title><![CDATA[Stories by Murat Aydın on Medium]]></title>
        <description><![CDATA[Stories by Murat Aydın on Medium]]></description>
        <link>https://medium.com/@murataydindev?source=rss-453d07344bd2------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*1TF-LDl77K9Dnte9FAmCzw.png</url>
            <title>Stories by Murat Aydın on Medium</title>
            <link>https://medium.com/@murataydindev?source=rss-453d07344bd2------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Wed, 18 Nov 2026 11:10:01 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@murataydindev/feed" rel="self" type="application/rss+xml"/>
        <webMaster><![CDATA[yourfriends@medium.com]]></webMaster>
        <atom:link href="http://medium.superfeedr.com/" rel="hub"/>
        <item>
            <title><![CDATA[16 KB Page Size in Android 15: Don’t Let Your App Break in November]]></title>
            <link>https://medium.com/@murataydindev/android-15-and-the-16-kb-page-size-what-developers-must-know-before-november-2025-36b7d22efa00?source=rss-453d07344bd2------2</link>
            <guid isPermaLink="false">https://medium.com/p/36b7d22efa00</guid>
            <dc:creator><![CDATA[Murat Aydın]]></dc:creator>
            <pubDate>Thu, 11 Sep 2025 07:45:31 GMT</pubDate>
            <atom:updated>2025-09-23T08:50:31.573Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*AmXjrmofQ4xiNrQPCcRA2w.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*6NV9-V1j4qd-dphS2ZgcpA.png" /></figure><p>Modern Android development isn’t just about Kotlin, Jetpack, and Compose. Deep under the hood, the way the operating system manages memory is changing — and it directly affects whether your app will even launch on future devices.</p><p>Starting November 1, 2025, Google Play will require apps targeting Android 15+ to support the new 16 KB memory page size. If your app (or any of its SDKs) uses native code, this change is not optional — your binaries must be rebuilt or your app will crash on devices that use 16 KB pages.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*31tAiYCAZLUzZQwUxWWGmA.png" /></figure><p>Let’s break this down.</p><h3>What is Page Size?</h3><p>Think of memory as a huge library. Instead of placing books randomly on shelves, the library uses identical boxes (pages) to store them.</p><ul><li>The CPU and kernel use these fixed-size pages to map virtual addresses to physical RAM.</li><li>Permissions (read/write/execute) are enforced at the page level.</li><li><strong>Translation Lookaside Buffers (TLBs)</strong> cache these mappings for speed.</li></ul><p>For years, Android used 4 KB pages. It was a good trade-off when devices had less RAM and fewer CPU cores. But modern apps are massive, and a larger page size reduces overhead:</p><ul><li>Fewer page-table entries</li><li>Fewer TLB lookups</li><li>Fewer costly page-table walks</li></ul><p>In simple terms: one big toll booth instead of four small ones.</p><h3>🧠 Meet the Hidden Heroes: MMU and TLB</h3><p>Every tap or scroll in your app triggers millions of memory operations. Two hardware units silently keep this chaos in order:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*AKfcj6HiP0ih_L2CYKWFYg.png" /></figure><ul><li><strong>MMU (Memory Management Unit)</strong> — Translates virtual addresses into physical ones and enforces permissions. Think of it as the mapmaker and gatekeeper of memory.</li><li><strong>TLB (Translation Lookaside Buffer)</strong> — A tiny notebook that caches translations for lightning-fast lookups. If the CPU finds what it needs here, it skips the long detour to the MMU.</li></ul><p>With 4 KB pages, the TLB constantly fills up and drops entries (thrashing), forcing the CPU back to the MMU repeatedly. The result: wasted cycles, slower performance, and CPUs spending more time on memory bookkeeping than running apps.</p><h3>🔑 The 16KB Leap Forward</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*g5D_WWz2du7qKmJdaNUi_Q.png" /></figure><p>Android 15 introduces <strong>16KB page sizes</strong> as the new standard. Bigger pages mean:</p><ul><li>The TLB can cover <strong>4× more memory at once</strong>.</li><li>The MMU handles <strong>far fewer configurations</strong>.</li><li>The CPU spends less time on translations and more time executing logic.</li></ul><h3>Real-World Gains (Measured by Google)</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*vZYBAGd9e6wL9i3BB6U5pg.png" /></figure><ul><li><strong>App launches:</strong> 3–30% faster</li><li><strong>Power draw during launch:</strong> ~4.5% lower</li><li><strong>Camera start:</strong> 4.5–6.6% faster</li><li><strong>System boot:</strong> ~8% faster (~950 ms)</li></ul><h3>The Trade-Offs</h3><p>Bigger pages aren’t free:</p><ul><li>Minimum allocation jumps from 4 KB to 16 KB.</li><li>That means <strong>small memory regions waste more space</strong> (internal fragmentation).</li><li>Example: a 5 KB mapping uses 8 KB on a 4 KB system, but 16 KB on a 16 KB system.</li></ul><p>Still, because page tables are 75% smaller, <strong>well-optimized systems often use less RAM overall</strong>.</p><h3>Who Needs to Care?</h3><p>Not every app is impacted. There are <strong>three scenarios</strong>:</p><ol><li><strong>Pure Kotlin/Java apps</strong><br>✅ No native .so files → You’re fine. Still, test on a 16 KB emulator.</li><li><strong>Apps with third-party SDKs (bundling </strong><strong>.so files)</strong><br>🔄 You must update SDKs to versions that are <strong>16 KB–compatible</strong>.</li></ol><ul><li>Example: React Native supports 16 KB starting from 0.77.</li><li>Realm, OpenSSL, and many analytics SDKs may include .so files.</li></ul><ol><li><strong>Apps with custom native code (NDK, C/C++/Rust)</strong><br>🔧 You must <strong>rebuild all native libraries</strong> with a recent NDK (r28+).</li></ol><ul><li>Older builds assume 4 KB and will crash on launch.</li></ul><h3>How to Check if Your App is Affected</h3><h3>Step 1: Look for .so files</h3><p>Run:</p><pre>zipinfo app-release.apk | grep &#39;\.so$&#39;</pre><p>Or use <strong>Android Studio → Build → Analyze APK</strong>.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*xMsWUUZvYiUv22hNVCaYCg.png" /></figure><p>If you see .so files in lib/arm64-v8a or lib/x86_64, your app has native code.</p><h3>Step 2: Verify alignment</h3><p>Use Google’s check_elf_alignment.sh script or llvm-objdump:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/fefeb6250c39cb4e6ebca4fa47281db6/href">https://medium.com/media/fefeb6250c39cb4e6ebca4fa47281db6/href</a></iframe><pre>llvm-objdump -p lib/yourlibrary.so | grep LOAD</pre><p>Look for align 2**14 → that means <strong>16 KB aligned</strong>.<br>Anything smaller (2<strong>13, 2</strong>12) → incompatible.</p><h3>Step 3: Emulator testing</h3><p>Create an <strong>Android 15 emulator</strong> with <strong>16 KB page size</strong>:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*C4FoTr5uaEo9X6zdgXqHfw.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*7mdE4ebwFU0L7YijkYp34A.png" /></figure><ul><li>In AVD settings → Advanced → Kernel page size → 16384</li><li>Launch your app.</li><li>If it crashes → not aligned.</li><li>If it runs → you’re safe.</li></ul><h3>Fixing Native Code</h3><h3>Use the Latest Tools</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*3Yvp3-caaPZNRTiSHPR_aA.png" /></figure><ul><li><strong>AGP 8.5.1+</strong> → Alignment is handled automatically.</li><li><strong>NDK r28+</strong> → Builds are 16 KB aligned by default.</li></ul><h3>If You’re on Older NDKs</h3><p>Add flexible page size flags in your <strong>Gradle (Kotlin DSL)</strong> configuration:</p><pre>android {<br>    defaultConfig {<br>        externalNativeBuild {<br>            cmake {<br>                arguments += listOf(&quot;-DANDROID_SUPPORT_FLEXIBLE_PAGE_SIZES=ON&quot;)<br>            }<br>        }<br>    }<br>}</pre><h3>For Very Old Toolchains</h3><p>If you cannot upgrade, force alignment via linker flags:</p><pre>android {<br>    defaultConfig {<br>        externalNativeBuild {<br>            cmake {<br>                cppFlags += listOf(<br>                    &quot;-Wl,-z,max-page-size=16384&quot;,<br>                    &quot;-Wl,-z,common-page-size=16384&quot;<br>                )<br>            }<br>        }<br>    }<br>}</pre><h3>Fix Hardcoded Assumptions</h3><p>If your code contains:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*mH-76pRGfKD-OmAdXK_kNA.png" /></figure><h3>Practical Example</h3><p>Suppose you are using <strong>OpenSSL</strong> or <strong>Realm</strong>:</p><ul><li>Download or build a version compiled with 16 KB alignment.</li><li>Update your build.gradle.kts:</li></ul><pre>android {<br>    packaging {<br>        jniLibs {<br>            useLegacyPackaging = false<br>        }<br>    }<br>}</pre><ul><li>Rebuild and test on a <strong>16 KB emulator</strong>.</li></ul><h3>Deadline and Enforcement</h3><p>📅 <strong>November 1, 2025</strong>: Google Play will block new submissions/updates targeting Android 15+ that aren’t 16 KB–compatible.</p><p>This isn’t just a performance enhancement — it’s a <strong>publishing gate</strong>.</p><h3>Key Takeaways</h3><ul><li><strong>Pure Kotlin/Java apps</strong>: You’re safe, just test.</li><li><strong>Any </strong><strong>.so files (yours or SDKs)</strong>: Must be rebuilt/updated.</li><li><strong>Use AGP 8.5.1+ and NDK r28+</strong> for easiest compliance.</li><li><strong>Test on a 16 KB emulator</strong> before shipping.</li></ul><p>The shift to 16 KB pages is like moving from a school zone to a highway — Android is finally using modern hardware efficiently. As developers, we just need to make sure our apps can keep up.</p><h3>📚 References</h3><ul><li><a href="https://android-developers.googleblog.com/">Android Developers Blog — 16 KB Page Support</a></li><li><a href="https://developer.android.com/ndk/downloads/revision_history">NDK r28 Changelog</a></li><li><a href="https://developer.android.com/guide/practices/page-sizes?hl=tr">Android Developer Practice</a></li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=36b7d22efa00" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Understanding Coroutine Scopes in Android]]></title>
            <link>https://medium.com/loodos/understanding-coroutine-scopes-in-android-9fa181ba8afb?source=rss-453d07344bd2------2</link>
            <guid isPermaLink="false">https://medium.com/p/9fa181ba8afb</guid>
            <category><![CDATA[coroutine]]></category>
            <category><![CDATA[android-development]]></category>
            <category><![CDATA[kotlin-coroutines]]></category>
            <category><![CDATA[kotlin]]></category>
            <category><![CDATA[android]]></category>
            <dc:creator><![CDATA[Murat Aydın]]></dc:creator>
            <pubDate>Mon, 03 Apr 2023 10:45:41 GMT</pubDate>
            <atom:updated>2023-04-03T11:49:11.946Z</atom:updated>
            <content:encoded><![CDATA[<h3>Understanding Coroutine Scopes in Android : <br>GlobalScope vs. ViewModelScope vs. LifecycleScope vs. rememberCoroutineScope:</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*pPkRzIelc-dL6KajX271eQ.jpeg" /></figure><p>When working with coroutines in Android, it’s important to understand the different scopes available to you. In this article, we’ll explore four of the most commonly used scopes: <strong>GlobalScope</strong>, <strong>ViewModelScope</strong>, <strong>LifecycleScope</strong>, and <strong>rememberCoroutineScope</strong>. We’ll examine the differences between these scopes and provide code examples to illustrate their usage.</p><p><strong>GlobalScope<br></strong> The <em>GlobalScope</em> is a top-level scope that can be used to launch coroutines that have a global lifetime. Coroutines launched in this scope will continue to execute until the application is terminated or until they are explicitly cancelled. The GlobalScope should be used sparingly, as it can easily lead to memory leaks and other issues.</p><p>Here’s an example of how to use GlobalScope to launch a coroutine that logs a message every second:</p><pre>GlobalScope.launch {<br>    while (true) {<br>        Log.d(&quot;Coroutine Example&quot;, &quot;Logging a message every second&quot;)<br>        delay(1000)<br>    }<br>}</pre><p><strong>ViewModelScope<br></strong> The <em>ViewModelScope</em> is a scope that is tied to a specific ViewModel. Coroutines launched in this scope will automatically be cancelled when the ViewModel is destroyed. This makes it a good choice for performing asynchronous operations that are tied to the lifecycle of a ViewModel.</p><p>Here’s an example of how to use ViewModelScope to launch a coroutine that retrieves data from a repository:</p><pre>class MyViewModel(private val repository: MyRepository): ViewModel() {<br>    fun fetchData() {<br>        viewModelScope.launch {<br>            val data = repository.getData()<br>            // Update UI with data<br>        }<br>    }<br>}</pre><p><strong>LifecycleScope<br></strong> The <em>LifecycleScope</em> is a scope that is tied to the lifecycle of a specific Android component, such as an Activity or Fragment. Coroutines launched in this scope will automatically be cancelled when the component is destroyed. This makes it a good choice for performing asynchronous operations that are tied to the lifecycle of a component.</p><p>Here’s an example of how to use LifecycleScope to launch a coroutine that retrieves data from a repository:</p><pre>class MyActivity : AppCompatActivity() {<br>    private val viewModel: MyViewModel by viewModels()<br>    private val scope = lifecycleScope<br><br>override fun onCreate(savedInstanceState: Bundle?) {<br>        super.onCreate(savedInstanceState)<br>        setContentView(R.layout.activity_main)<br><br>        scope.launch {<br>            val data = viewModel.getData()<br>            // Update UI with data<br>        }<br><br>        scope.launchWhenCreated {<br>            val data = viewModel.getData()<br>            // Update UI with data<br>            // launchWhenCreated will launch coroutine if the lifecycle is at least on create state and gets suspended if it&#39;s on destroy state.<br>        }<br>        <br>        scope.launchWhenStarted {<br>            // Perform operations when the Activity is in the Started state<br>            // launchWhenStarted will launch coroutine if the lifecycle is at least on start state and gets suspended if it&#39;s on stop state.<br>        }<br>        scope.launchWhenResumed {<br>            // Perform operations when the Activity is in the Resumed state<br>            // launchWhenResumed will launch coroutine if the lifecycle is at least on resume state and gets suspended if it&#39;s on pause state.<br>        }<br>    }<br>}</pre><p><strong>rememberCoroutineScope</strong></p><p>The <em>rememberCoroutineScope</em> is a scope that can be used in composable functions in Jetpack Compose. Coroutines launched in this scope will automatically be cancelled when the composable function is removed from the composition. This makes it a good choice for performing asynchronous operations that are tied to the lifecycle of a composable function.</p><p>Here’s an example of how to use rememberCoroutineScope to launch a coroutine that retrieves data from a repository in a composable function:</p><pre>@Composable<br>fun MyComposableFunction(viewModel: MyViewModel) {<br>    val scope = rememberCoroutineScope()<br>LaunchedEffect(Unit) {<br>        val data = viewModel.getData()<br>        // Update UI with data<br>    }<br>}</pre><p><strong>Conclusion</strong><br>In this article, we’ve explored the differences between GlobalScope, ViewModelScope, LifecycleScope, and rememberCoroutineScope. Each scope has its own advantages and disadvantages, and choosing the right one for your use case is important. By understanding the differences between these scopes and how to use them, you’ll be able to write better, more efficient coroutine code in your Android app.</p><p>If you have suggestions and comments, please specify.</p><p><strong>For more details;</strong></p><ul><li>Kotlin Coroutine Scopes: <a href="https://kotlinlang.org/docs/coroutines-scopes.html">https://kotlinlang.org/docs/coroutines-scopes.html</a></li><li>Global Coroutine Scope: <a href="https://developer.android.com/topic/libraries/architecture/coroutines#global-scope">https://developer.android.com/topic/libraries/architecture/coroutines#global-scope</a></li><li>ViewModel Coroutine Scope: <a href="https://developer.android.com/topic/libraries/architecture/coroutines#viewmodel-scope">https://developer.android.com/topic/libraries/architecture/coroutines#viewmodel-scope</a></li><li>Lifecycle Coroutine Scope: <a href="https://developer.android.com/topic/libraries/architecture/coroutines#lifecycle-scope">https://developer.android.com/topic/libraries/architecture/coroutines#lifecycle-scope</a></li><li>rememberCoroutineScope: <a href="https://developer.android.com/reference/kotlin/androidx/compose/runtime/package-summary.html#remembercoroutinescope-kotlin.coroutines.coroutinescope-">https://developer.android.com/reference/kotlin/androidx/compose/runtime/package-summary.html#remembercoroutinescope-kotlin.coroutines.coroutinescope-</a></li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=9fa181ba8afb" width="1" height="1" alt=""><hr><p><a href="https://medium.com/loodos/understanding-coroutine-scopes-in-android-9fa181ba8afb">Understanding Coroutine Scopes in Android</a> was originally published in <a href="https://medium.com/loodos">Loodos</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Protect Https connection with SSL Pinning on Android]]></title>
            <link>https://medium.com/@murataydindev/protect-https-connection-with-ssl-pinning-on-android-e0a35955d583?source=rss-453d07344bd2------2</link>
            <guid isPermaLink="false">https://medium.com/p/e0a35955d583</guid>
            <category><![CDATA[ssl-pinning]]></category>
            <category><![CDATA[android]]></category>
            <category><![CDATA[security]]></category>
            <category><![CDATA[ssl-certificate]]></category>
            <category><![CDATA[certificate]]></category>
            <dc:creator><![CDATA[Murat Aydın]]></dc:creator>
            <pubDate>Mon, 15 Nov 2021 12:07:57 GMT</pubDate>
            <atom:updated>2022-08-22T08:52:04.016Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/726/1*kzkFHcOoIVNhThsRuibklg.png" /></figure><p>One of the most important things to consider when developing an application is secure communication with the remote server. You can share various information, make payments, etc. between your application and the server. Of course, we do not want this information to be captured by someone else.</p><h4>So why do we need SSL certificate pinning?</h4><p>When your application tries to establish a connection to a server, it cannot determine which certificates it can or cannot trust. Apps rely on certificates from Android CAs provided by Google.</p><p>This method also causes vulnerabilities. An attacker can generate a self-signed certificate or hack a root CA certificate. Thus, it allows an attacker to perform a <a href="https://en.wikipedia.org/wiki/Man-in-the-middle_sald%c4%b1r%c4%b1s%c4%b1">Man-in-the-middle attack </a>and capture the data sent from your application.</p><p>If we say what can be done to prevent this, restricting the set of trusted certificates by pinning prevents attackers from analyzing the functionality of the application and the way it communicates with the server.</p><h3>Types of SSL Certificate Pinning with CertificatePinner</h3><ul><li><strong>Pin the certificate</strong>: You can download the server’s certificate and package it in your application. At runtime, the application compares the server’s certificate with the one you added.</li><li><strong>Fix the public key:</strong> You can get the public key of the certificate and include it as a string in your code. At runtime, the application compares the certificate’s public key with the hard-coded key in your code.</li></ul><p>Choosing between these two options depends on your needs and server configuration. If you choose the first option, you must publish a new version of your application whenever your server changes its certificate or stops working. If you choose the second option, it may violate the key rotation policy, as the public key does not change.</p><h4>OkHttp/Retrofit and CertificatePinner</h4><p>You will need <a href="https://square.github.io/okhttp/">OkHTTP</a> which provides a method to do SSL Pinning with just a few lines of code. OkHTTP, CertificatePinner makes this process easy.</p><p>You can see the certificates you will add by clicking the lock icon of your browser or you can request them from the security team of your service provider.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/984/1*-SJBnQrwkZs0fWJiooj5gQ.png" /></figure><p>I recommend using SHA-256 for your SSL Secure as it is more secure than SHA1.<br>You will need to translate the certificates you have downloaded in the SHA256 format that we will use when pinning.<br>You can do this with the following commands from the terminal.<br>Run the command by typing your own filename (instead of cert.pem) in the file directory where your certificate is located.</p><pre>openssl x509 -in my-certificate.crt -pubkey -noout | openssl pkey -pubin -outform der | openssl dgst -sha1 -binary | openssl enc -base64</pre><pre><strong>Base64 encoded SHA</strong></pre><pre>openssl x509 -in my-certificate.crt -pubkey -noout | openssl pkey -pubin -outform der | openssl dgst -sha256 -binary | openssl enc -base64</pre><pre><strong>Base64 encoded SHA256</strong></pre><p>We pin the certificate in Sha256 format in our application as follows.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/aa5e8600efcb3da639110e4c3e38359d/href">https://medium.com/media/aa5e8600efcb3da639110e4c3e38359d/href</a></iframe><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/2e06137c0b61d18f055be33f396016c8/href">https://medium.com/media/2e06137c0b61d18f055be33f396016c8/href</a></iframe><p>SSL Certificates have an expiration date, so SHA-256 also has an expiration date. When the certificate expires, you will need to provide a new SHA-256 for the new certificate.</p><p>Fortunately, CertificatePinner can handle multiple PINs.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/645d856b88ccadc27c6e60b8adb1d0a9/href">https://medium.com/media/645d856b88ccadc27c6e60b8adb1d0a9/href</a></iframe><p>So if you get the new certificate in advance, you can hardcode it into your app and then ask your user to update the app if the certificate has expired, so they get the latest version with the new certificate. You can add new certificates without deleting the old certificates from the application if there are factors such as those that appeal to a large audience and do not want to have a force update.</p><p>As a better solution, instead of manually adding our ssl pins into the application in order to add the ever-changing certificate to the application and not become a release dependent, we can pull our ssl pins dynamically from the remote config as in the example I shared below.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/3b6f8b2f91f7e40bd452658cd41867cf/href">https://medium.com/media/3b6f8b2f91f7e40bd452658cd41867cf/href</a></iframe><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/d6a1f70eaac24f3339ca023f06da7c44/href">https://medium.com/media/d6a1f70eaac24f3339ca023f06da7c44/href</a></iframe><h3>Summary</h3><ul><li>Get your certificates from your security team or your browser.</li><li>Create your SHA256/SHA1 pins using the command line.</li><li>Create an instance of CertificatePinner.</li><li>Add the CertificatePinner instance to your okhttp.</li><li>Make this process dynamic with the help of RemoteConfig.</li></ul><h4>EXTRA: How to View Trusted Root Certificates on an Android Device</h4><ol><li>Open settings</li><li>Tap “Security &amp; location”</li><li>Tap “Encryption and credentials”</li><li>Tap “Trusted credentials”. This displays a list of all trusted certificates on the device.</li><li>You can also install, remove or disable trusted certificates from the“Encryption and credentials” page.</li></ol><figure><img alt="" src="https://cdn-images-1.medium.com/max/221/1*bD3zGu9zGjw8mfwUkDj1Lg.gif" /></figure><p>If you liked the article, don’t forget to press the clap button :)</p><p>You can follow me on <a href="https://www.linkedin.com/in/murataydin1/"><strong>Linkedin</strong></a>.</p><p><strong>Resources</strong></p><ul><li><a href="https://security.stackexchange.com/questions/20803/how-does-ssl-tls-work/20833#20833">How does SSL/TLS work?</a></li><li><a href="https://www.netguru.com/blog/3-ways-how-to-implement-certificate-pinning-on-android">3 Ways How To Implement Certificate Pinning on Android</a></li></ul><p><a href="https://developer.android.com/training/articles/security-ssl">https://developer.android.com/training/articles/security-ssl</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=e0a35955d583" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Google Play In-App Review API nedir?]]></title>
            <link>https://medium.com/@murataydindev/google-play-in-app-review-api-nedir-29f792ed7d57?source=rss-453d07344bd2------2</link>
            <guid isPermaLink="false">https://medium.com/p/29f792ed7d57</guid>
            <category><![CDATA[google-play-store]]></category>
            <category><![CDATA[in-app-reviews]]></category>
            <category><![CDATA[android-app-development]]></category>
            <dc:creator><![CDATA[Murat Aydın]]></dc:creator>
            <pubDate>Fri, 25 Sep 2020 11:14:18 GMT</pubDate>
            <atom:updated>2022-09-27T10:53:32.469Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*cuPfKPRRHQ_ujlaD_Gd5Vw.jpeg" /></figure><p>Google Play Uygulama İçi İnceleme API’si, uygulama içerisinden ayrılmadan kullanıcılardan uygulamanız için Play Store derecelendirme ve yorumlarını göndermelerini istemenizi sağlar.</p><h3>Cihaz gereksinimleri</h3><ul><li>Android cihazlar, Android 5.0 (API seviyesi 21) veya daha yüksek bir sürümde çalışıyor olmalı ve Google Play Store yüklü olmalıdır.</li><li>Uygulama içi incelemeleri uygulamanıza entegre etmek için uygulamanızın <a href="https://developer.android.com/guide/playcore">Play Core kitaplığının</a> 1.8.0 veya sonraki sürümünü kullanması gerekir.</li></ul><h3>Entegrasyon</h3><p>Entegrasyon aşamasında ki adımları detaylı anlatarak ilerleyeceğim.<br>Öncelikle bu bağımlılığı eklemeniz gerekiyor:</p><pre>// In your app’s build.gradle file:<br>...<br>dependencies {<br>// This dependency is downloaded from the <a href="https://developer.android.com/studio/build/dependencies#google-maven"><strong>Google’s Maven repository</strong></a>.<br>    // So, make sure you also include that repository in your project&#39;s build.gradle file.</pre><pre>    implementation &#39;com.google.android.play:review:2.0.0&#39;<br><br>    // For Kotlin users also add the Kotlin extensions library for Play In-App Review:</pre><pre>    implementation &#39;com.google.android.play:review-ktx:2.0.0&#39;<br>    ...<br>}</pre><p>Bağımlılık eklendikten sonra, artık inceleme akışını tetiklemek için gerekli sınıflara erişimimiz var. Bunlar:</p><ul><li><strong>ReviewManager</strong> — inceleme bilgilerini almak ve inceleme akışını başlatmak için kullanılan sınıf. Bunun iki işlevi vardır; biri inceleme bilgilerini almak ve diğeri inceleme akışını başlatmak içindir.</li><li><strong>ReviewInfo</strong> — inceleme akışını başlatmak için kullanılan gerekli bilgileri tutan sınıf.</li></ul><p><strong>ReviewManager’ı</strong> kullanarak, uygulamamız için gerekli ReviewInfo referansını talep edebilir ve daha sonra bu referansı kullanıcı için inceleme akışını tetiklemek için kullanabiliriz.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*AzuT-3O1Zt8nZpyfRIPnbA.png" /></figure><p>Devam etmeden ve inceleme akışını başlatmadan önce, <strong>ReviewManager’a</strong> referans almamız gerekiyor. Bu, <strong>ReviewManagerFactory</strong> kullanılarak, <strong>create</strong> işlevinin çağrılması ve bir context referansın <strong>iletilmesi</strong> gerekiyor:</p><pre>val manager = ReviewManagerFactory.create(context)</pre><p>Bu oluşturma işlevi bize ReviewManager sınıfının bir örneğini sağlayacaktır. Manager oluştuğunda, <strong>requestReviewFlow</strong> işlevini kullanabiliriz . Bu, uygulamamız için incelemeyi görüntülemek için gerekli bilgileri alacak olan asenkron bir çağrıdır.</p><pre>val request = manager.requestReviewFlow()</pre><p>Bu eşzamansız bir işlem olduğu için incelemeyi gösterebilmemiz için tamamlanmasını beklememiz gerekir. Bu, gözden geçirme bilgilerinin, inceleme istendiğinde hemen kullanılamayacağı anlamına gelir.<br>Bu süre, kullanıcıların ağ bağlantısına göre büyük ölçüde değişebilir. Bu nedenle, Görev tamamlandığında bir dinleyici eklememiz gerekir.</p><p>Bu şekilde gözden geçirme bilgisi bir kez alındığında bunu kullanıcıya gösterebiliriz.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/2134b6e9de91777742f9f7656c4df806/href">https://medium.com/media/2134b6e9de91777742f9f7656c4df806/href</a></iframe><p>Bazı durumlarda istek başarısız olabilir ve bu durumda kullanıcıya hiçbir şey göstermek istemeyiz. Sadece istek başarılı olursa, ReviewInfo örneğini isteğin sonucundan alabiliriz. Bu ReviewInfo referansını kullanarak ReviewManager referansımızdan launchReviewFlow işlevini kullanarak inceleme akışını tetikleyebiliriz:</p><pre>val flow = manager.launchReviewFlow(activity, reviewInfo)</pre><p>launchReviewFlow çağrıldığında, inceleme akışı hazırlanacak ve potansiyel olarak kullanıcıya gösterilecektir. Potansiyel olarak söylüyorum çünkü launchReviewFlow işlevinin inceleme akışını başlatacağının garanti edilmediğini unutmamak önemlidir.</p><p>Google Play’de, bir kullanıcının inceleme sayfasını ne sıklıkla görüntüleyebileceğine dair kota uygulamaktadır. Kota aşılırsa, bu akışın inceleme sayfasının görüntülenmemesine sebep olur.</p><p>Kotalarla ilgili bilgiye <a href="https://developer.android.com/guide/playcore/in-app-review#quotas"><strong>buradan</strong></a> ulaşabilirsiniz.<br>Bu nedenle, kullanıcılarınız için kafa karıştırıcı bir duruma neden olabileceğinden, uygulamanızda incelemeleri tetikleyecek herhangi bir şey göstermemek önemlidir.</p><p>Bu eşzamansız bir işlem olduğundan, istek bize herhangi bir veri döndürmez, ancak yine de bir tamamlanma durumuna sahiptir. Tamamlanma durumu, inceleme akışının bittiği anlamına gelir .</p><p>(inceleme akışının gösterilip gösterilmediğini veya kullanıcının gerçekten bir incelemeden ayrılıp ayrılmadığını göstermez, daha çok uygulamamızda herhangi bir işleme devam etmemiz için bir gösterge görevi görür).</p><pre>flow.addOnCompleteListener { _ -&gt;<br>    // The flow has finished. The API does not indicate whether the user<br>    // reviewed or not, or even whether the review dialog was shown. Thus, no<br>    // matter the result, we continue our app flow.<br>}</pre><p>Yukarıdaki kodla, tarafımızdan çok fazla kod gerekmeden yerinde bir inceleme akışımız var. Bununla birlikte, işlemlerin eşzamansız davranışıyla, bu akışlardan hiçbirinin tetiklendiğinde anında gerçekleşmesi garanti edilmez; örneğin, incelemeyi göstermeyi ve kullanıcının uygulamanızın başka bir bölümüne geçmesini isteyebilirsiniz, bu da inceleme iletişim kutusunun kesintiye uğramasına neden olabilir. Ekrandan uzaklaştığında isteği iptal edebilsek de, bu durum devam edebilir ve kullanıcının uygulamanız için hiçbir zaman yorum bırakmamasına neden olabilir, çünkü inceleme bilgileri gerektiğinde hazır olmayabilir.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/3092fa1b3779e85f9aaac468cf29c16a/href">https://medium.com/media/3092fa1b3779e85f9aaac468cf29c16a/href</a></iframe><h3>İncelemeyi ne zaman göstermeliyiz?</h3><p>Yararlı geri bildirim sağlamak için içerdeki kullanıcı uygulamanızı yeterince deneyimledikten sonra uygulama içi inceleme akışını tetikleyin.Burada ki akış tamamen sizin uygulamanıza özel olabilir. Örneğin bir satın alma işlemi, puan kazanma, seviye atlama gibi işlemlerden sonra gösterilebilir. O zaman, kullanıcı iyi bir ruh hali içinde olacak ve inceleme muhtemelen daha olumlu olacaktır.</p><p>Kullanıcıdan aşırı derecede inceleme istemeyin. Uygulamayı açtıktan sonra bir inceleme istemek kötü bir fikirdir, çünkü ya atlayacak ya da size kötü bir yorum vermesine neden olabilir..</p><p>Kullanıcıya bir miktar değer sunduktan sonra inceleme istemek mantıklıdır. O zaman, kullanıcı iyi bir ruh hali içinde olacak ve inceleme muhtemelen daha olumlu olacaktır.</p><h3>Test</h3><p>Google Play’deki test kanallarında yapılabilir (Dahili Test, Alfa veya Beta.)</p><p>Uygulamanızı yayınlayın ve mevcut Google Hesabınızın henüz uygulamayı incelemediğinden emin olun. Test kanallarında kota yoktur, bu nedenle her zaman iletişim kutusunu göreceksiniz. Bir derecelendirme gönderirseniz, inceleme olarak değil, test geri bildirimi olarak eklenir.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*ns6gstqTva_DDlktXCq5Zw.png" /></figure><p>İşlevselliği uygulamak ve test etmek için kendi uygulamamda denedim ve başarılı sonuç aldım.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/738/1*Dwz2LOMwVC502FkhIPptxQ.jpeg" /></figure><p>İlk medium yazım olduğundan eksiklerim olabilir, geri bildirim verirseniz sevinirim.<br>Makaleyi beğendiyseniz alkış düğmesine basmayı unutmayın :)</p><p><a href="https://www.linkedin.com/in/murataydin1/"><strong>Linkedin</strong></a>’den beni takip edebilirsiniz.</p><p>Kaynaklar</p><p><a href="https://developer.android.com/guide/playcore/in-app-review">https://developer.android.com/guide/playcore/in-app-review</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=29f792ed7d57" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>