एपीके build.gradle में कीस्टोर जानकारी डाले बिना साइन इन करें

Question

मैं साइन इन करने की प्रक्रिया सेटअप करने का प्रयास कर रहा हूं, ताकि प्रोजेक्ट की फ़ाइल में कीस्टॉर पासवर्ड और की पासवर्ड जमा न होंbuild.gradle ।

वर्तमान में मेरे पास निम्नलिखित हैं build.gradle:

android {
    ...
    signingConfigs {
        release {
            storeFile file("my.keystore")
            storePassword "store_password"
            keyAlias "my_key_alias"
            keyPassword "key_password"
        }
    }

    buildTypes {
        release {
            signingConfig signingConfigs.release            
        }
    }
}

यह पूरी तरह से ठीक काम करता है लेकिन मुझे और मेरे भंडार में मूल्यों को नहीं डालना चाहिए । मैं नहीं डाल करने के लिए पसंद करेंगे और वहाँ या तो।storePasswordkeyPasswordstoreFilekeyAlias

क्या कोई ऐसा तरीका है build.gradleजिससे वह किसी बाहरी स्रोत से पासवर्ड प्राप्त करेगा (जैसे एक फ़ाइल जो केवल मेरे कंप्यूटर पर रहती है)?

और निश्चित रूप से, परिवर्तित build.gradleकिसी अन्य कंप्यूटर पर उपयोग करने योग्य होना चाहिए (भले ही कंप्यूटर में पासवर्ड तक पहुंच न हो)।

अगर यह मायने रखता है तो मैं एंड्रॉइड स्टूडियो और मैक ओएस एक्स मावेरिक्स में उपयोग कर रहा हूं।

Comments

"और निश्चित रूप से, परिवर्तित बिल्ड.ग्रेड किसी अन्य कंप्यूटर पर भी उपयोग करने योग्य होना चाहिए (भले ही कंप्यूटर में पासवर्ड तक पहुंच न हो)" - यदि डेटा में नहीं है build.gradle, तो आपके पास इसके अलावा कुछ और होना चाहिए build.gradle, क्या यह पर्यावरण चर (प्रति एक उत्तर), एक गुण फ़ाइल (एक अन्य उत्तर के अनुसार), या कुछ अन्य साधनों के लिए एक समायोजन है। यदि आप बाहर की चीजों को करने के लिए तैयार नहीं हैं build.gradle, तो परिभाषा के अनुसार सभी हस्ताक्षरित जानकारी अंदर होनी चाहिए buid.gradle।

— कॉमन्सवेयर

@CommonsWare आप सही हैं। मैंने यह नहीं बताया कि मैं build.gradle के भीतर कड़ाई से कुछ भी करना चाहता हूं, हालांकि। और मैंने बताया कि build.gradle कुछ बाहरी स्रोत से पासवर्ड प्राप्त

— Bobrovsky

ग्रैडल का उपयोग करके एक रिलीज़ साइन इन की गई एपीके फ़ाइल

— user2768

मैंने meta.stackoverflow.com/questions/311044/… के आधार पर stackoverflow.com/questions/18328730/… के डुप्लिकेट के रूप में फ़्लैग किया है

— user2768

Answer 1

ग्रूवी के बारे में अच्छी बात यह है कि आप जावा कोड को स्वतंत्र रूप से मिला सकते हैं, और कुंजी / मान फ़ाइल का उपयोग करके पढ़ना बहुत आसान है java.util.Properties। शायद मुहावरेदार Groovy का उपयोग करने का एक आसान तरीका है, लेकिन जावा अभी भी बहुत सरल है।

एक keystore.propertiesफ़ाइल बनाएं (इस उदाहरण में, अपनी परियोजना के रूट डायरेक्टरी के बगल में settings.gradle, हालाँकि आप इसे जहाँ चाहें वहाँ रख सकते हैं:

storePassword=...
keyPassword=...
keyAlias=...
storeFile=...

इसे अपने में जोड़ें build.gradle:

allprojects {
    afterEvaluate { project ->
        def propsFile = rootProject.file('keystore.properties')
        def configName = 'release'

        if (propsFile.exists() && android.signingConfigs.hasProperty(configName)) {
            def props = new Properties()
            props.load(new FileInputStream(propsFile))
            android.signingConfigs[configName].storeFile = file(props['storeFile'])
            android.signingConfigs[configName].storePassword = props['storePassword']
            android.signingConfigs[configName].keyAlias = props['keyAlias']
            android.signingConfigs[configName].keyPassword = props['keyPassword']
        }
    }
}

Comments

मुझे अपने कीस्टोरे.प्रॉपीटीज़ के उद्धरणों को हटाना था

— जैकब तबक

यह प्लगइन संस्करण 0.9। + के साथ मेरे लिए हस्ताक्षरित संस्करण उत्पन्न नहीं करता है। मुझे साइनिंग कॉनफिग्स ब्लॉक और buildTypes.release.signingConfig आइटम के साथ क्या करना है? उन्हें हटा दो?

— फर्नांडो गैलेगो

ऐसा लगता है कि किसी भी वैध मान (जैसे storeFile file('AndroidManifest.xml')) के लिए storeFile की स्थापना और फिर बाद में इसे अधिलेखित करने के लिए हस्ताक्षर प्रक्रिया जगह लेता है।

— चमत्कार 2

बिल्डिंग त्रुटि के कारण Error:(24, 0) Could not find property 'android' on root project 'RootProjectName'जहां लाइन 24 इफ-ब्लॉक के साथ एक है। apply plugin: 'com.android.application'रूट build.gradle में जोड़ने से बिल्ड विफल भी हो सकता है। मैं क्या गलत कर रहा हूं?

— फिललैब

यह वर्ष 2018 पर काम नहीं करता है। यह पदावनत होना चाहिए? फेंकने की त्रुटि है किCould not get unknown property 'android' for root project

— नियॉन वारगे

Answer 2

वैकल्पिक रूप से, यदि आप स्कॉट बार्टा के उत्तर को ऑटो जेनरेटेड ग्रेड कोड के समान लागू करना चाहते हैं, तो आप keystore.propertiesअपने प्रोजेक्ट रूट फ़ोल्डर में एक फ़ाइल बना सकते हैं :

storePassword=my.keystore
keyPassword=key_password
keyAlias=my_key_alias
storeFile=store_file  

और अपने ग्रेड कोड को संशोधित करें:

// Load keystore
def keystorePropertiesFile = rootProject.file("keystore.properties");
def keystoreProperties = new Properties()
keystoreProperties.load(new FileInputStream(keystorePropertiesFile))

...

android{

    ...

    signingConfigs {
        release {
            storeFile file(keystoreProperties['storeFile'])
            storePassword keystoreProperties['storePassword']
            keyAlias keystoreProperties['keyAlias']
            keyPassword keystoreProperties['keyPassword']
        }
    }

    ...

}

आप इस प्रॉपर्टी फ़ाइल को अपने मॉड्यूल की जड़ में स्टोर कर सकते हैं, जिस स्थिति में बस चूक जाती है rootProject, और आप इस कोड को संशोधित करके विभिन्न कीस्टोर्स और कुंजी उपनामों के गुणों के कई सेट कर सकते हैं।

Comments

बहुत अच्छा काम करता है। मैं if ( keystorePropertiesFile.exists() )यह सुनिश्चित करने के लिए उपयोग करता था कि फ़ाइल विशेषताओं को प्राप्त करने और हस्ताक्षर करने का प्रयास करने से पहले मौजूद है।

— जोशुआ पिंटर

और फ़ाइल .txtके अंत में एक्सटेंशन जोड़ना न भूलें keystore.properties।

— लेवोन पेट्रोसेन

आपको फ़ाइल .txtपर एक्सटेंशन की आवश्यकता नहीं होनी चाहिए keystore.properties।

— मैट ज़ुकोवस्की

ऐसा लगता है कि इस जानकारी को यहाँ जोड़ा गया था - developer.android.com/studio/publish/…

— वादिम कोटोव

Answer 3

~/.gradle/gradle.propertiesफ़ाइल बनाने का सबसे आसान तरीका है ।

ANDROID_STORE_PASSWORD=hunter2
ANDROID_KEY_PASSWORD=hunter2

तब आपकी build.gradleफ़ाइल इस तरह दिख सकती है:

android {
    signingConfigs {
        release {
            storeFile file('yourfile.keystore')
            storePassword ANDROID_STORE_PASSWORD
            keyAlias 'youralias'
            keyPassword ANDROID_KEY_PASSWORD
        }
    }
    buildTypes {
        release {
            signingConfig signingConfigs.release
        }
    }
}

Comments

क्या मुझे gitignore ~ ​​/ .gradle / gradle.properties चाहिए?

— vzhen

पूर्ण निर्देश भी देशी दस्तावेज की प्रतिक्रिया है।

— पेन्सिलचेक

Answer 4

कुछ लिंक पढ़ने के बाद:

http://blog.macromates.com/2006/keychain-access-from-shell/ http://www.thoughtworks.com/es/insights/blog/signing-open-source-android-apps-without-disclosing- पासवर्ड

चूंकि आप मैक ओएसएक्स का उपयोग कर रहे हैं, आप अपने पासवर्ड को स्टोर करने के लिए किचेन एक्सेस का उपयोग कर सकते हैं।

फिर आपकी वर्गीकृत स्क्रिप्ट में:

/* Get password from Mac OSX Keychain */
def getPassword(String currentUser, String keyChain) {
    def stdout = new ByteArrayOutputStream()
    def stderr = new ByteArrayOutputStream()
    exec {
        commandLine 'security', '-q', 'find-generic-password', '-a', currentUser, '-gl', keyChain
        standardOutput = stdout
        errorOutput = stderr
        ignoreExitValue true
    }
    //noinspection GroovyAssignabilityCheck
    (stderr.toString().trim() =~ /password: '(.*)'/)[0][1]
}

इस तरह का उपयोग करें:

getPassword (करेंटियर, "Android_Store_Password")

/* Plugins */
apply plugin: 'com.android.application'

/* Variables */
ext.currentUser = System.getenv("USER")
ext.userHome = System.getProperty("user.home")
ext.keystorePath = 'KEY_STORE_PATH'

/* Signing Configs */
android {  
    signingConfigs {
        release {
            storeFile file(userHome + keystorePath + project.name)
            storePassword getPassword(currentUser, "ANDROID_STORE_PASSWORD")
            keyAlias 'jaredburrows'
            keyPassword getPassword(currentUser, "ANDROID_KEY_PASSWORD")
        }
    }

    buildTypes {
        release {
            signingConfig signingConfigs.release
        }
    }
}

Comments

हालांकि आपका जवाब केवल मैक OSX पर लागू होता है, मुझे यह बहुत पसंद है! ध्यान दें कि आपके द्वारा प्रदान किए गए दूसरे लिंक में अन्य प्लेटफार्मों के लिए बैकअप समाधान शामिल है, यदि किसी को मल्टी-प्लेटफ़ॉर्म समर्थन को लागू करने की आवश्यकता है।

— डेलब्लैंको

क्या आप कृपया linux और windows के लिए भी समान समाधान प्रदान कर सकते हैं? धन्यवाद।

— जे मुंगारा

Answer 5

यह मेरा इसे करने का तरीका है। पर्यावरण चर का उपयोग करें

  signingConfigs {
    release {
        storeFile file(System.getenv("KEYSTORE"))
        storePassword System.getenv("KEYSTORE_PASSWORD")
        keyAlias System.getenv("KEY_ALIAS")
        keyPassword System.getenv("KEY_PASSWORD")
    }

Comments

दुर्भाग्य से, इसके लिए प्रत्येक कंप्यूटर पर प्रत्येक प्रोजेक्ट के लिए सिस्टम वातावरण बनाने की आवश्यकता होती है । अन्यथा मुझे निम्नलिखित त्रुटि मिलती हैNeither path nor baseDir may be null or empty string. path='null'

— बोब्रोव्स्की

@ याकूब्रोव्स्की मुझे पता है कि इस प्रश्न का उत्तर दिया गया है, लेकिन आप सिस्टम पर्यावरण चर या gradle.properties फ़ाइल का उपयोग कर सकते हैं। आप संभवतः gradle.properties फ़ाइल का उपयोग करना चाहते हैं। आप इसे कई परियोजनाओं के लिए उपयोग कर सकते हैं।

— जारेड बुर्स

यह MacOSX पर तब तक काम नहीं करता है जब तक आप कमांड लाइन से एंड्रॉइड स्टूडियो नहीं चलाते हैं।

— हेनरिक डी सोसा

मैं उपरोक्त सभी से सहमत हूं। मेरे पास समान कॉन्फ़िगरेशन है और आप इसे एंड्रॉइड स्टूडियो में संकलित नहीं कर सकते। आपको काम करने के लिए कमांड लाइन से चलने की आवश्यकता है। मैं एक बेहतर तरीके की तलाश में हूं, ताकि मुझे एंड्रॉइड स्टूडियो में चलने पर इन पंक्तियों पर टिप्पणी न करनी पड़े।

— सयोज वलसन

@ याकूबोवस्की: क्या यह खिड़कियों पर काम करता है ?. क्या हमें सिस्टम वातावरण में इन सभी का उल्लेख करना चाहिए?

— डीकेवी

Answer 6

किसी भी फ़ाइल को संपादित किए बिना कमांड लाइन से किसी भी मौजूदा एंड्रॉइड स्टूडियो ग्रेडल प्रोजेक्ट को लेना और बनाना / साइन करना संभव है। यह आपकी कुंजी और पासवर्ड को अलग रखते हुए संस्करण नियंत्रण में आपके प्रोजेक्ट को संग्रहीत करने के लिए बहुत अच्छा बनाता है और आपकी बिल्ड.ग्रेड फ़ाइल में नहीं:

./gradlew assembleRelease -Pandroid.injected.signing.store.file=$KEYFILE -Pandroid.injected.signing.store.password=$STORE_PASSWORD -Pandroid.injected.signing.key.alias=$KEY_ALIAS -Pandroid.injected.signing.key.password=$KEY_PASSWORD

Answer 7

स्वीकृत उत्तर प्रोजेक्ट को उसी रूट फ़ोल्डर में रहने वाले एपीके पर हस्ताक्षर करने के लिए किस कीस्टॉर का उपयोग करने के लिए नियंत्रित करने के लिए एक फ़ाइल का उपयोग करता है। जब हम जीआईटी जैसे वीक्स का उपयोग कर रहे हैं , तो एक बुरी बात हो सकती है जब हम सूची को अनदेखा करने के लिए गुण फ़ाइल जोड़ना भूल जाते हैं। क्योंकि हम अपने पासवर्ड का खुलासा दुनिया के सामने करेंगे। समस्याएं अभी भी कायम हैं।

हमारी परियोजना के भीतर एक ही निर्देशिका में गुण फ़ाइल बनाने के बजाय, हमें इसे बाहर करना चाहिए। हम इसे gradle.properties फ़ाइल का उपयोग करके बाहर बनाते हैं।

यहाँ कदम हैं:

1. अपने रूट प्रोजेक्ट पर विस्तार करें या gradle.properties बनाएँ और निम्नलिखित कोड जोड़ें, अपने साथ पथ संपादित करना याद रखें:

AndroidProject.signing=/your/path/androidproject.properties  

2.Create androidproject.properties में / अपने / पथ / और इसके लिए निम्न कोड जोड़ें, अपने keystore पथ में /your/path/to/android.keystore बदलना न भूलें:

STORE_FILE=/your/path/to/android.keystore  
STORE_PASSWORD=yourstorepassword  
KEY_ALIAS=yourkeyalias  
KEY_PASSWORD=yourkeypassword  

3. अपने ऐप मॉड्यूल में बिल्ड.ग्रेडल (आपकी परियोजना रूट बिल्ड बिल्ड नहीं है ।ग्रेड) मौजूद नहीं है या इसके लिए समायोजित होने पर निम्न कोड जोड़ें:

signingConfigs {  
     release  
   }  
   buildTypes {  
   debug {  
     debuggable true  
   }  
   release {  
     minifyEnabled true  
     proguardFiles getDefaultProguardFile('proguard-android.txt'), 'proguard-rules.pro'  
     signingConfig signingConfigs.release  
   }  
 }  

4. चरण 3 में कोड के नीचे निम्नलिखित कोड जोड़ें:

if (project.hasProperty("AndroidProject.signing")  
     && new File(project.property("AndroidProject.signing").toString()).exists()) {  
     def Properties props = new Properties()  
     def propFile = new File(project.property("AndroidProject.signing").toString())  
     if(propFile.canRead()) {  
      props.load(new FileInputStream(propFile))  
      if (props!=null && props.containsKey('STORE_FILE') && props.containsKey('STORE_PASSWORD') &&  
         props.containsKey('KEY_ALIAS') && props.containsKey('KEY_PASSWORD')) {  
         android.signingConfigs.release.storeFile = file(props['STORE_FILE'])  
         android.signingConfigs.release.storePassword = props['STORE_PASSWORD']  
         android.signingConfigs.release.keyAlias = props['KEY_ALIAS']  
         android.signingConfigs.release.keyPassword = props['KEY_PASSWORD']  
      } else {  
         println 'androidproject.properties found but some entries are missing'  
         android.buildTypes.release.signingConfig = null  
      }  
     } else {  
            println 'androidproject.properties file not found'  
          android.buildTypes.release.signingConfig = null  
     }  
   }  

यह कोड चरण 1 से gradro.properties में AndroidProject.signing संपत्ति के लिए खोज करेगा । यदि संपत्ति मिली, तो यह संपत्ति के मूल्य को फ़ाइल पथ के रूप में अनुवादित करेगा जो androidproject.properties को इंगित करता है जो हम चरण 2 में बनाते हैं । तब इसमें से सभी संपत्ति मूल्य का उपयोग हमारे बिल्ड.ग्रेड के लिए कॉन्फ़िगरेशन साइनिंग के रूप में किया जाएगा।

अब हमें अपने कीस्टोर पासवर्ड को उजागर करने के जोखिम के बारे में फिर से चिंता करने की आवश्यकता नहीं है।

Build.gradle में keystore की जानकारी डाले बिना Android APK साइनिंग पर अधिक पढ़ें

Comments

यह मेरे लिए ठीक काम करता है। बस यह जानने के लिए कि वे क्यों स्टोर फाइल का उपयोग कर रहे हैं (System.getenv ("KEYSTORE"))

— DKV

Answer 8

बाहरी JSON फ़ाइल में अपनी साख लगाने के इच्छुक लोगों के लिए और यह पढ़ें कि क्या यह मैंने किया है:

my_project / credentials.json:

{
    "android": {
        "storeFile": "/path/to/acuity.jks",
        "storePassword": "your_store_password",
        "keyAlias": "your_android_alias",
        "keyPassword": "your_key_password"
    }
}

my_project / एंड्रॉयड / ऐप्स / build.gradle

// ...
signingConfigs {
        release {

            def credsFilePath = file("../../credentials.json").toString()
            def credsFile = new File(credsFilePath, "").getText('UTF-8')
            def json = new groovy.json.JsonSlurper().parseText(credsFile)
            storeFile file(json.android.storeFile)
            storePassword = json.android.storePassword
            keyAlias = json.android.keyAlias
            keyPassword = json.android.keyPassword
        }
        ...
        buildTypes {
            release {
                signingConfig signingConfigs.release //I added this
                // ...
            }
        }
    }
// ...
}

जिस कारण से मैंने एक .jsonफ़ाइल प्रकार चुना , और .propertiesफ़ाइल प्रकार नहीं (जैसा कि स्वीकृत उत्तर में है), यह इसलिए है क्योंकि मैं उसी डेटा () में अन्य डेटा (अन्य आवश्यक प्रॉपर्टीज) को भी स्टोर करना चाहता था my_project/credentials.json, और अभी भी मेरे पास ग्रेड पार्स है उस फ़ाइल के भीतर से भी जानकारी पर हस्ताक्षर करना।

Comments

मेरे लिए सबसे अच्छा समाधान की तरह लगता है।

— आकांक्षा देव

Answer 9

इस प्रश्न को कई मान्य उत्तर मिले हैं, लेकिन मैं अपना कोड साझा करना चाहता था जो लाइब्रेरी मेंटेनरों के लिए उपयोगी हो सकता है , क्योंकि यह मूल को build.gradleकाफी साफ छोड़ देता है ।

मैं मॉड्यूल निर्देशिका में एक फ़ोल्डर जोड़ता हूं जो मैं gitignore। यह इस तरह दिख रहा है:

/signing
    /keystore.jks
    /signing.gradle
    /signing.properties

keystore.jksऔर signing.propertiesआत्म व्याख्यात्मक होना चाहिए। और signing.gradleइस तरह दिखता है:

def propsFile = file('signing/signing.properties')
def buildType = "release"

if (!propsFile.exists()) throw new IllegalStateException("signing/signing.properties file missing")

def props = new Properties()
props.load(new FileInputStream(propsFile))

def keystoreFile = file("signing/keystore.jks")
if (!keystoreFile.exists()) throw new IllegalStateException("signing/keystore.jks file missing")

android.signingConfigs.create(buildType, {
    storeFile = keystoreFile
    storePassword = props['storePassword']
    keyAlias = props['keyAlias']
    keyPassword = props['keyPassword']
})

android.buildTypes[buildType].signingConfig = android.signingConfigs[buildType]

और मूल build.gradle

apply plugin: 'com.android.application'
if (project.file('signing/signing.gradle').exists()) {
    apply from: 'signing/signing.gradle'
}

android {
    compileSdkVersion 27
    defaultConfig {
        applicationId ...
    }
}

dependencies {
    implementation ...
}

जैसा कि आप देख सकते हैं, आपको बिल्डटेप को बिल्कुल भी निर्दिष्ट करने की आवश्यकता नहीं है, यदि उपयोगकर्ता के पास एक वैध signingनिर्देशिका तक पहुंच है , तो वह इसे मॉड्यूल में रखता है और वह एक वैध हस्ताक्षरित रिलीज़ एप्लिकेशन का निर्माण कर सकता है, अन्यथा यह उसके लिए काम करता है। यह सामान्य रूप से होगा।

Comments

मुझे वास्तव में यह समाधान पसंद है। ध्यान दें, ब्लॉक के apply fromबाद आना चाहिएandroid

— mgray88 11:10

Answer 10

आप कमांड लाइन से पासवर्ड का अनुरोध कर सकते हैं:

...

signingConfigs {
  if (gradle.startParameter.taskNames.any {it.contains('Release') }) {
    release {
      storeFile file("your.keystore")
      storePassword new String(System.console().readPassword("\n\$ Enter keystore password: "))
      keyAlias "key-alias"
      keyPassword new String(System.console().readPassword("\n\$ Enter keys password: "))
    } 
  } else {
    //Here be dragons: unreachable else-branch forces Gradle to create
    //install...Release tasks.
    release {
      keyAlias 'dummy'
      keyPassword 'dummy'
      storeFile file('dummy')
      storePassword 'dummy'
    } 
  }
}

...

buildTypes {
  release {

    ...

    signingConfig signingConfigs.release
  }

  ...
}

...

यह उत्तर पहले दिखाई दिया था: https://stackoverflow.com/a/33765572/3664487

Comments

हालांकि यह लिंक प्रश्न का उत्तर दे सकता है, लेकिन उत्तर के आवश्यक भागों को शामिल करना और संदर्भ के लिए लिंक प्रदान करना बेहतर है। लिंक-केवल उत्तर अमान्य हो सकते हैं यदि लिंक किए गए पृष्ठ बदल जाते हैं। - समीक्षा से

— mkobit

@mkobit, यह स्टैक ओवरफ्लो की सामग्री का लिंक है! मैं, लिंक की गई सामग्री को कॉपी और पेस्ट कर सकता था, लेकिन वह डुप्लिकेट सामग्री की ओर जाता है। इस प्रकार, मैं मानता हूं, और मुझे सही करें यदि मैं गलत हूं, तो लिंक पोस्ट करना सबसे अच्छा समाधान है। कोई भी तर्क जो "लिंक किए गए पृष्ठ परिवर्तन" को खारिज कर दिया जाना चाहिए, इस आधार पर कि यहां सामग्री भी बदल सकती है। मैं हटाने के लिए आपके समाधान के खिलाफ मजबूत सलाह देता हूं! क्योंकि लिंक की गई सामग्री एक उत्कृष्ट समाधान प्रदान करती है।

— user2768

खैर, मुझे लगता है कि समस्या यह है कि यह अभी भी एक "लिंक-ओनली" उत्तर है। मुझे लगता है कि समाधान को एक टिप्पणी के रूप में पोस्ट करना है, प्रश्न को एक डुप्लिकेट के रूप में चिह्नित करना है, या यहां एक नया उत्तर लिखना है जो समस्या को संबोधित करता है।

— mkobit

"लिंक-ओनली" उत्तरों को कुछ उदाहरणों में प्रोत्साहित किया जाना चाहिए। फिर भी, मैंने आपकी सलाह और अनुलिपि सामग्री का अनुसरण किया है। (डुप्लिकेटेड सामग्री स्पष्ट रूप से समस्याग्रस्त है, क्योंकि कुछ सामग्री अपडेट की जा सकती है, जबकि शेष सामग्री नहीं हो सकती है।)

— user2768

वास्तव में, मैंने सिर्फ उत्तर को अपडेट किया है और डुप्लिकेट सामग्री समस्याओं का कारण बन रही है! यदि लिंक-ओनली उत्तरों के विरुद्ध कोई नीति है, तो इस तरह के कोने के मामलों पर विचार करने के लिए इसे अनुकूलित किया जाना चाहिए।

— 16:27 पर user2768

Answer 11

मेरे पासवर्ड में एक विशेष चरित्र था, जो डॉलर $ पर हस्ताक्षर करता था और मुझे उस एंकल में बचना था। उसके बाद, हस्ताक्षर करना मेरे लिए काम कर गया।