Android Studio, Kotlin के साथ पूरी तरह से काम करता है, ताकि आप Kotlin फ़ाइलों को आपके मौजूदा प्रोजेक्ट में जोड़ें और Java लैंग्वेज कोड को Kotlin में बदलें. इसके बाद, अपने Kotlin कोड के साथ Android Studio के सभी मौजूदा टूल इस्तेमाल किए जा सकते हैं, इसमें ऑटोकंप्लीट, लिंट की जांच, रीफ़ैक्टरिंग, डीबगिंग वगैरह शामिल हैं.
अगर आपको नया प्रोजेक्ट शुरू करना है और Kotlin का इस्तेमाल करना है, तो प्रोजेक्ट बनाएं.
सैंपल के लिए, यहां देखें: Kotlin के कोड के सैंपल.
मौजूदा प्रोजेक्ट में Kotlin जोड़ना
अपने प्रोजेक्ट में Kotlin जोड़ने के लिए, यह तरीका अपनाएं:
फ़ाइल > नया और कई Android टेंप्लेट में से कोई एक चुनें, जैसे नए खाली फ़्रैगमेंट के तौर पर, जैसा कि पहली इमेज में दिखाया गया है. सूची न दिखने पर इस मेन्यू में जाकर, पहले प्रोजेक्ट विंडो खोलें और अपने ऐप मॉड्यूल का इस्तेमाल करेगा.
पहली इमेज. उपलब्ध टेंप्लेट में से चुनें, जैसे कि फ़्रैगमेंट या गतिविधि. इसके बाद, दिख रहे विज़र्ड में, सोर्स भाषा के लिए Kotlin चुनें. दूसरी इमेज में, Android पर की गई नई गतिविधि वाला डायलॉग दिखाया गया है. इससे पता चलता है कि आपको कब कोई नई गतिविधि बनाएं.
दूसरी इमेज. नई Android गतिविधि का डायलॉग बॉक्स, जिसमें यह किया जा सकता है Kotlin को अपनी सोर्स भाषा के तौर पर चुनें. विज़ार्ड के ज़रिए जारी रखें.
वैकल्पिक रूप से, आप फ़ाइल > नया > Kotlin फ़ाइल/क्लास की मदद से बेसिक Kotlin फ़ाइल. अगर आपको यह विकल्प नहीं दिखता है, तो प्रोजेक्ट विंडो खोलें और java डायरेक्ट्री चुनें. नई Kotlin फ़ाइल/क्लास विंडो से आपको ये सुविधाएं मिलती हैं फ़ाइल का नाम तय करें और फ़ाइल टाइप के लिए कई विकल्प दें: फ़ाइल, Class, इंटरफ़ेस, Enum क्लास या ऑब्जेक्ट. आपका चुना गया विकल्प नई Kotlin फ़ाइल में, आपके लिए बनाया गया बेसिक स्ट्रक्चर तय करता है. अगर आपको Class चुनें, तो Android Studio दिए गए लिंक के साथ एक नई Kotlin सोर्स फ़ाइल बनाता है नाम और मेल खाती हुई क्लास की परिभाषा. इंटरफ़ेस चुनने पर, आपको एक इंटरफ़ेस फ़ाइल में बताया गया है और आगे भी इसी तरह.
अगर आपने पहली बार अपने प्रोजेक्ट को हटाने का अनुरोध किया है (Android टेम्प्लेट का उपयोग किए बिना), तो Android Studio चेतावनी देती है कि प्रोजेक्ट में Kotlin कॉन्फ़िगर नहीं किया गया है, जैसा कि तीसरी इमेज में दिखाया गया है. इसके ऊपर दाएं कोने में, कॉन्फ़िगर करें पर क्लिक करके Kotlin को कॉन्फ़िगर करें संपादक या इवेंट लॉग की सूचना में, जो नीचे दाएं कोने में पॉप-अप होता है.
Kotlin की मदद वाले सभी मॉड्यूल के लिए, Kotlin को कॉन्फ़िगर करने का विकल्प चुनें फ़ाइलें अटैच करने के लिए कहें, जैसा कि चौथी इमेज में दिखाया गया है:
OK पर क्लिक करने के बाद, Android Studio आपके प्रोजेक्ट क्लासपाथ में Kotlin को जोड़ देता है और
हर उस मॉड्यूल पर Kotlin Android प्लगिन लागू करता है जिसमें Kotlin फ़ाइलें होती हैं.
आपकी build.gradle फ़ाइलें, इन उदाहरणों से मिलती-जुलती दिखनी चाहिए:
ग्रूवी
// Project build.gradle file.
buildscript {
ext.kotlin_version = '1.4.10'
...
dependencies {
classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlin_version"
}
}
Kotlin
// Project build.gradle.kts file.
buildscript {
extra["kotlin_version"] = "1.4.10"
...
dependencies {
classpath("org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlin_version")
}
}
ग्रूवी
// Inside each module using kotlin
plugins {
...
id 'kotlin-android'
}
...
dependencies {
implementation 'androidx.core:core-ktx:1.3.2'
implementation "org.jetbrains.kotlin:kotlin-stdlib:$kotlin_version"
}
Kotlin
// Inside each module using kotlin
plugins {
...
kotlin("android")
}
...
val kotlin_version: String by rootProject.extra
dependencies {
implementation("androidx.core:core-ktx:1.3.2")
implementation("org.jetbrains.kotlin:kotlin-stdlib:$kotlin_version")
}
सोर्स संगठन
डिफ़ॉल्ट रूप से, नई Kotlin फ़ाइलों को src/main/java/ में सेव किया जाता है. इससे यह काम आसान हो जाता है
Kotlin और Java, दोनों फ़ाइलों को एक ही जगह पर देखने के लिए. अगर आपको अलग-अलग
आपके पास अपनी Java फ़ाइलों की Kotlin फ़ाइलों को सेव करने का विकल्प है, तो आपको Kotlin फ़ाइलों को
अगर आपके पास इन फ़ॉर्मैट की फ़ाइल नहीं है, तो src/main/kotlin/ बटन का इस्तेमाल करें. अगर ऐसा किया जाता है, तो आपको इसे भी शामिल करना होगा
आपकी sourceSets की डायरेक्ट्री
कॉन्फ़िगरेशन, जैसा कि नीचे दिखाया गया है:
ग्रूवी
android {
sourceSets {
main.java.srcDirs += 'src/main/kotlin'
}
}
Kotlin
android {
sourceSets {
getByName("main") {
java.srcDir("src/main/kotlin")
}
}
}
मौजूदा Java कोड को Kotlin कोड में बदलें
Java कोड को Kotlin में बदलने के लिए, Android Studio में Java फ़ाइल खोलें और कोड > Java फ़ाइल को Kotlin फ़ाइल में बदलें. इसके अलावा, नया Kotlin बनाएं फ़ाइल (फ़ाइल > नई > Kotlin फ़ाइल/क्लास) और फिर अपना Java कोड उस फ़ाइल को कॉपी कर सकते हैं. इसके बाद, Android Studio आपके कोड को बदलने का प्रॉम्प्ट और ऑफ़र दिखाता है करने के लिए डिज़ाइन किया गया है, जैसा कि पांचवीं इमेज में दिखाया गया है. बदलने के लिए, हां पर क्लिक करें. आपके पास विकल्प के तौर पर अगली बार यह डायलॉग न दिखाएं को चुनें. इससे, आने वाले समय में कन्वर्ज़न हो सकते हैं स्वचालित हैं.
कोड का कन्वर्ज़न और अमान्य वैल्यू
Android Studio की कन्वर्ज़न प्रोसेस, एक जैसा Kotlin कोड जनरेट करती है जो कंपाइल हो जाता है और चलता है. हालांकि, यह संभावना है कि आपको रूपांतरित कोड के लिए ऑप्टिमाइज़ेशन. उदाहरण के लिए, हो सकता है कि आप बदला गया कोड अमान्य टाइप को हैंडल करता है.
Android में, View ऑब्जेक्ट और अन्य चीज़ों को शुरू करने में देरी होना आम बात है
कॉम्पोनेंट, जब तक कि फ़्रैगमेंट या ऐक्टिविटी
लाइफ़साइकल की सही स्थिति. उदाहरण के लिए, आपके पास
बटन पर क्लिक करें, जैसा कि नीचे दिए गए स्निपेट में दिखाया गया है:
public class JavaFragment extends Fragment {
// Null until onCreateView.
private Button button;
@Override
public View onCreateView(@NonNull LayoutInflater inflater, ViewGroup container,
Bundle savedInstanceState) {
View root = inflater.inflate(R.layout.fragment_content, container,false);
// Get a reference to the button in the view, only after the root view is inflated.
button = root.findViewById(R.id.button);
return root;
}
@Override
public void onViewCreated(@NonNull View view, @Nullable Bundle savedInstanceState) {
super.onViewCreated(view, savedInstanceState);
// Not null at this point of time when onViewCreated runs
button.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
...
}
});
}
}
बटन वैरिएबल शून्य होने लायक है. हालांकि, व्यवहारिक तौर पर यह
इस उदाहरण में इस्तेमाल किए जाने पर, इसे कभी भी शून्य नहीं होना चाहिए. हालांकि, चूंकि इसका मान
कंस्ट्रक्शन के समय असाइन होने पर, जनरेट किया गया Kotlin कोड Button के साथ काम करता है
को शून्य होने वाले टाइप के तौर पर शामिल करता है. साथ ही, बटन को खोलने के लिए, गैर-शून्य दावे ऑपरेटर का इस्तेमाल करता है
क्लिक लिसनर जोड़ते समय:
class JavaFragment : Fragment() {
// Null until onCreateView.
private var button: Button? = null
override fun onCreateView(inflater: LayoutInflater, container: ViewGroup?,
savedInstanceState: Bundle?): View? {
...
// Get a reference to the button in the view, only after the root view is inflated.
button = root.findViewById(R.id.button)
...
}
override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
super.onViewCreated(view, savedInstanceState)
// Not null at the point of time when onViewCreated fires
// but force unwrapped nonetheless
button!!.setOnClickListener { }
}
}
इस मामले में, lateinit का इस्तेमाल करने के मुकाबले यह कन्वर्ज़न कम बेहतर होगा, क्योंकि आपने
को गैर-शून्य दावे या सेफ़-कॉल के साथ बटन संदर्भ को खोलने के लिए मजबूर किया जाता है
ऑपरेटर को उन सभी जगहों पर डाल दिया जाएगा जहां इसकी पहुंच है.
अन्य मामलों में, जहां null आपकी
ऐप्लिकेशन के इस्तेमाल के उदाहरण के साथ, सेवा उपलब्ध कराने वाले एल्विस के साथ सेफ़-कॉल (?.) ऑपरेटर का इस्तेमाल करना
ऑपरेटर (?:) ऑपरेटर,
शून्य वाले ऑब्जेक्ट या किसी ऐसी डिफ़ॉल्ट वैल्यू का इस्तेमाल करें जो शून्य से जुड़ी न हो. Android स्टूडियो
के पास यह तय करने के लिए पर्याप्त जानकारी नहीं है कि
कन्वर्ज़न प्रोसेस के बारे में ज़्यादा जानें. हालांकि, यह गैर-शून्य दावे पर डिफ़ॉल्ट होता है, इसलिए आपको यह करना चाहिए
फ़ॉलो अप कर सकते हैं और रूपांतरित कोड में ज़रूरत के मुताबिक बदलाव कर सकते हैं.
ज़्यादा जानकारी
अपने प्रोजेक्ट में Kotlin और Java कोड, दोनों का इस्तेमाल करने के बारे में ज़्यादा जानकारी के लिए, यहां देखें Kotlin की मदद से Java कोड कॉल करना.
एंटरप्राइज़ स्थितियों में Kotlin का इस्तेमाल करने के बारे में ज़्यादा जानकारी के लिए, यहां देखें बड़ी टीमों के लिए Kotlin का इस्तेमाल करना.
मौजूदा Android API के मुहावरे Kotlin रैपर के बारे में जानकारी के लिए, देखें Android केटीएक्स.