महान सुधार!

यह socket.io के साथ मदद करेगा जो डिफ़ॉल्ट रूप से 85000ms का टाइमर रखता है। RN मास्टर पर थ्रेशोल्ड 60000ms ।

और फायरबेस जो लंबे समय से उपयोग कर रहा है।

मुझे फायरबेस लाइब्रेरी का उपयोग करते हुए चेतावनी मिल रही है

Setting a timer for a long period of time, i.e. multiple minutes, is a performance and correctness issue on Android as it keeps the timer module awake, and timers can only be called when the app is in the foreground. See https://github.com/facebook/react-native/issues/12981 for more info. (Saw setTimeout with duration 111862ms)

इस चेतावनी से कैसे छुटकारा पाएं ...

मुझे फायरबेस लाइब्रेरी का भी उपयोग करते हुए चेतावनी मिल रही है। किसी को पता है कि इस समस्या को कैसे हल किया जाए?

मुझे फायरबेस के साथ यह चेतावनी भी मिल रही है।

"firebase": "^3.9.0",
"react-native": "0.44.0"

एक ही मुद्दा ( 85000ms ) लेकिन बिना firebase । पैकेजों की मेरी सूची:

  "dependencies": {
    "apisauce": "0.11.0",
    "format-json": "1.0.3",
    "lodash": "4.17.4",
    "markdown-it": "^8.3.1",
    "native-base": "^2.1.3",
    "normalizr": "^3.2.2",
    "prop-types": "^15.5.10",
    "querystringify": "1.0.0",
    "ramda": "0.23.0",
    "react": "16.0.0-alpha.6",
    "react-markdown": "^2.5.0",
    "react-native": "0.44.0",
    "react-native-animatable": "1.2.0",
    "react-native-config": "0.4.2",
    "react-native-device-info": "0.10.2",
    "react-native-drawer": "2.3.0",
    "react-native-htmlview": "0.9.0",
    "react-native-i18n": "1.0.0",
    "react-native-linear-gradient": "^2.0.0",
    "react-native-photo-view": "^1.2.0",
    "react-native-router-flux": "3.39.1",
    "react-native-scrollable-tab-view": "*",
    "react-native-share": "^1.0.20",
    "react-native-vector-icons": "4.1.1",
    "react-navigation": "^1.0.0-beta.9",
    "react-redux": "5.0.4",
    "redux": "3.6.0",
    "redux-persist": "4.6.0",
    "redux-saga": "0.15.3",
    "reduxsauce": "0.4.1",
    "seamless-immutable": "7.1.2"
  },
  "devDependencies": {
    "ava": "^0.18.2",
    "babel-eslint": "^7.1.1",
    "babel-preset-es2015": "^6.18.0",
    "enzyme": "^2.6.0",
    "husky": "^0.13.1",
    "ignite-animatable": "^0.3.1",
    "ignite-dev-screens": "^2.0.0-beta.9",
    "ignite-i18n": "^0.1.1",
    "ignite-ir-boilerplate-2016": "^0.2.2",
    "ignite-vector-icons": "^0.2.1",
    "mockery": "^2.0.0",
    "nyc": "^10.1.2",
    "react-addons-test-utils": "^15.3.1",
    "react-dom": "^15.4.0",
    "react-native-mock": "^0.3.1",
    "reactotron-apisauce": "^1.7.0",
    "reactotron-react-native": "^1.7.0",
    "reactotron-redux": "^1.7.0",
    "reactotron-redux-saga": "^1.7.0",
    "snazzy": "^6.0.0",
    "standard": "^8.6.0"
  }

मैं एंड्रॉइड पर 0.44.0 का उपयोग करके एक समान समस्या का सामना कर रहा हूं। मैं भी फायरबेस का उपयोग नहीं कर रहा हूं:

Setting a timer for a long period of time, i.e. multiple minutes, is a performance and correctness issue on Android as it keeps the timer module awake, and timers can only be called when the app is in the foreground. See https://github.com/facebook/react-native/issues/12981 for more info. (Saw setTimeout with duration 85000ms)

हाय वहाँ लोग .. सोच रहा था कि क्या इसके लिए कोई त्वरित काम है। मैं उपयोग कर रहा हूँ:

react-native 0.44 react 16.0.0-alpha.6 feathers-socketio 1.6.0

जब मैं विकसित कर रहा हूँ तो इसकी बहुत कष्टप्रद पॉपिंग है .. वैसे भी क्या मैं अभी के लिए चेतावनी छिपा सकता हूँ ??

एक ही मुद्दा यहाँ firebase 3.9.0 के साथ

यदि यह आपको परेशान करता है तो आप console.ignoredYellowBox = ['Setting a timer']; जोड़ते हैं

@ स्केव-हेडलेस ओपिनियन इनकमिंग। :)

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

इस स्थिति में, आप इन टाइमआउट को कॉन्फ़िगर कर सकते हैं और उन्हें कम कर सकते हैं, या उनके साथ काम करने का एक अलग तरीका सेटअप कर सकते हैं। हो सकता है कि पुस्तकालयों के रख-रखाव करने वालों को भी हल करने के लिए कहें और एक समाधान के साथ आने में मदद करने के लिए कहें।

मेरी सलाह है, इस सूत्र का पालन करें जब तक कि कोई स्मार्ट वास्तविक समाधान के साथ नहीं आता है, इसलिए आप उस उत्तर के साथ खुद को शिक्षित कर सकते हैं। और फिर हो सकता है, इस बीच (यदि आप समस्या को समाप्त नहीं कर सकते / नहीं करना चाहते) तो चेतावनी को अनदेखा करें।

टी एल; डॉ;

हां, आप अस्थायी रूप से चेतावनियों को नजरअंदाज कर सकते हैं। बस हर अब और फिर जाँच करें कि स्थिति क्या है और यदि कोई कार्यवाही आवश्यक है।

@ मुझे लगता है कि रेक्टोट्रॉन है

मुझे लगता है कि रेक्टोट्रॉन द्वारा

यदि हां, तो इस चेतावनी को केवल अनदेखा किया जा सकता है।
... हालाँकि मेरा एंड्रॉइड एमुलेटर कभी-कभी धीमा हो रहा है, शायद यह एक कारण है।

@imamatory मुझे उम्मीद है कि असली समाधान उतना ही आसान है

नमस्ते, मुझे लगता है कि मुझे इसका हल मिला:
सबसे पहले आपको अपनी परियोजना में निम्नलिखित फ़ाइल ढूंढनी होगी: पुस्तकालयों / कोर / टाइमर / JSTimer; js
इसे खोलें और आपको अपनी अवधि बढ़ाने के लिए बस इस कॉन्स्टेंस MAX_TIMER_DURATION_MS को बदलना है, चेतावनी के अंत में लिखा है!

@nicolasZZ हाय, समाधान के लिए धन्यवाद। लेकिन क्या हमारे अपने कोड के बजाय JSTimer लाइब्रेरी को संशोधित करने का एक अच्छा अभ्यास है?

@nicolasZZ @AmroAly मेरे मन में इस समस्या का समाधान नहीं एक अच्छा अभ्यास है क्योंकि यह बहुत अस्थिर है, सबसे अच्छा सूचनाओं को अनदेखा करते हुए आधिकारिक समाधान जारी किया गया है है।

console.ignoredYellowBox = [
    'Setting a timer'
]

@ स्केव-हेडलेस का समाधान अच्छा है लेकिन मेरे मामले में केवल कोष्ठक के बीच "दर्ज" के साथ काम करता है

@rigobcastro धन्यवाद कि कष्टप्रद अलर्ट छुपाता है।

@ DZuz14 यह भयानक होगा यदि आप एक पीआर भेज सकते हैं या कम से कम बातचीत शुरू कर सकते हैं। धन्यवाद 👍

हाय ~
मैंने सॉकेट का उपयोग किया। nodejs and RN44 or RN 45
मैंने इस समय की चेतावनी दी।

मुझे इसका हल मिल गया
reference reactotron PR

व्यक्तिगत सर्वर नोडज और स्कोकैट.आईओ

const express = require('express')
const app = express()
const server = require('http').Server(app)
const io = require('socket.io')(server, {pingTimeout: 30000})

धन्यवाद!

मेरे पास एंड्रॉइड के लिए एक साधारण प्रतिक्रिया देशी परियोजना है और मैं लॉगिन और साइनअप के लिए प्रतिक्रिया मूल के साथ फायरबेस का उपयोग कर रहा हूं, लेकिन मुझे वह पीली त्रुटि मिली, मुझे क्या करना चाहिए? Stackoverlow (https://stackoverflow.com/questions/44603362/setting-a-timer-for-a-long-period-of-time-ie-multiple-minutes) में मेरे प्रश्न का लिंक

साभार @ DZuz14
मुझे यह त्रुटि तब लगी जब मैंने react-native run-android चलाए

D:\Projects 2016\Web\Android\mohajerkade-android\android\app\src\main\java\com\mohajerkade\AlarmManagerModule.java:40: error: cannot find symbol
       Intent intent = new Intent(context, AlarmReceiver.class);
                                           ^
  symbol:   class AlarmReceiver
  location: class AlarmManagerModule
1 error
:app:compileDebugJavaWithJavac FAILED

FAILURE: Build failed with an exception.

* What went wrong:
Execution failed for task ':app:compileDebugJavaWithJavac'.
> Compilation failed; see the compiler error output for details.

मैं लॉगिन और साइनअप के लिए प्रतिक्रिया मूलक के साथ फायरबेस का उपयोग करना चाहता हूं, लेकिन मुझे वह पीली त्रुटि मिली,
1: यह मॉड्यूल वास्तव में क्या है?
2: मेरी परियोजना को इस मॉड्यूल की आवश्यकता क्यों है?

मैंने इस लिंक के माध्यम से स्टैकओवरफ्लो से पूछा: (https://stackoverflow.com/questions/44603362/setting-a-timer-for-a-long-period-of-time-ie-multiple-minutes)
मैंने इस लिंक के माध्यम से Google Firebase टीम को रिपोर्ट किया: (https://github.com/firebase/firebase-js-sdk/issues/97)

@ DZuz14 मैं @saeedhei रूप में एक ही सवाल मिला है।

मूल रूप से हम firebase नोड मॉड्यूल का उपयोग कर रहे हैं जो इन लंबी अवधि के टाइमर का उपयोग करता है।

अपने मॉड्यूल को जोड़ना पर्याप्त नहीं है मुझे लगता है, हमें वास्तव में जावास्क्रिप्ट अलार्म के बजाय अपने अलार्म का उपयोग करने के लिए firebase नोड मॉड्यूल के भीतर कोड को फिर से लिखना होगा?

धन्यवाद @ DZuz14

इसलिए यदि आप firebase नामक npm पैकेज में देखते हैं, तो आप पाएंगे कि यह काफी जगहों पर setTimeout का उपयोग करता है। यह ठीक है क्योंकि लाइब्रेरी वेबसाइटों और नोड.जेएस सर्वर के लिए लिखी गई थी। react-native एक नोड.जेएस सर्वर की तरह है, लेकिन यह एक फोन पर चलता है - और जैसा कि चेतावनी सही ढंग से बताती है - लंबे समय तक चलने वाला जावास्क्रिप्ट इस वातावरण में अच्छा नहीं है और बैटरी को सूखा सकता है और अन्य अवांछित दुष्प्रभाव हो सकते हैं। ।

इसलिए मुझे लगता है कि हमें फायरबेस लोगों को वास्तव में अपने दृष्टिकोण में बदलाव करना होगा और विशेष रूप से react-native लिए बनाए गए पैकेज को वितरित करना होगा।

@BerndWessels https://www.npmjs.com/package/react-native-firebase क्या आपने इसे देखा है? कहते हैं, यह देशी धागे पर फायरबेस को चलाने की अनुमति देता है। यह निश्चित नहीं है कि यह कितना सच है, लेकिन देखने लायक हो सकता है। आप भी इसका उपयोग कर रहे होंगे, मुझे यकीन नहीं है।

@ DZuz14 धन्यवाद, मैं इसकी जाँच करूँगा।

कंसोल .ignoredYellowBox = [
'एक टाइमर की स्थापना'
]

@rigobcastro इस कोड को मैं कहां से इनपुट या पेस्ट कर सकता हूं?

@ Jazz747 अपनी सेटअप फ़ाइल के शीर्ष पर उदाहरण के लिए app.js, index.android.js या index.n.s.

console.ignoredYellowBox = [ 'Setting a timer' ]
यह कोड केवल मूल निवासी के अंदर चेतावनी छिपाता है।

ब्राउज़र कंसोल के अंदर चेतावनी के बारे में कैसे?

क्या कोई जानता है कि क्या आरएन टीम या समुदाय का कोई व्यक्ति इस मुद्दे के समाधान पर काम कर रहा है?

चेतावनी पॉपअप इस मुद्दे पर पुनर्निर्देश करता है, लेकिन मुझे चेतावनी को छिपाने के अलावा यहां कोई उचित समाधान नहीं मिल रहा है, जो कि समाधान नहीं है। कोई विचार या सुझाव?

@SuhairZain सब कुछ इंगित करता है कि RN को बाहरी पुस्तकालयों की त्रुटियां हैं

@rigobcastro इस चेतावनी को एक लंबे समय के साथ setInterval() कॉल के साथ आसानी से पुन: पेश किया जा सकता है (जो मेरे मामले में 5 मिनट था)। तो मैं कहूंगा कि यह 3 पार्टी के कामों के कारण नहीं है।

BTW, मैंने तब से यहां एक लाइब्रेरी ढूंढ ली है: प्रतिक्रिया-मूल-पृष्ठभूमि-टाइमर जो मुझे काम करने में मदद करता है।

@SuhairZain हाँ ठीक है! मेरी समस्या तीसरे पक्ष के परिवाद के साथ थी, लेकिन स्वामी ने त्रुटि को ठीक कर दिया (मुझे लगता है कि उन्होंने कुछ setInterval() बदल दिया था) और चेतावनी दी गई थी।

अच्छी सिफारिश, धन्यवाद।

मैं यहाँ एक ही समस्या है और अभी भी समझ सकता था कि मुझे इस समस्या से कैसे निपटना चाहिए।

rn: 0.45.1
फायरबेस: 4.1.3

प्रिय @escalepion मैंने

@escalepion यदि आपकी समस्या लंबे समय से चल रहे समय को स्थापित करने के बारे में है, तो कृपया मेरी टिप्पणी ऊपर देखें और देखें कि क्या यह आपकी मदद करता है।

@SuhairZain क्षमा करें, मैं समझ सकता था कि

क्या किसी को इस बात की टिप है कि किस लाइब्रेरी को नुकसान पहुंचाना है? मैंने हाल ही में आरएन को 0.46 में अपग्रेड किया और अचानक यह त्रुटि दिखाई दी। मेरी परियोजना में मेरे पास कुछ पुस्तकालय हैं और मैं केवल एक-एक करके उनकी जांच करने के बारे में सोच सकता हूं, जो स्पष्ट रूप से आदर्श नहीं है।

चीयर्स!

@ abeltje1 , यदि आप यह पता

@liketurbo मुझे यकीन है कि के लिए

मैं हर 30 मिनट में एपीआई टोकन को फिर से अमान्य करने के लिए redux-saga साथ इस मुद्दे पर आ रहा हूं।

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

फिर मेरा सवाल यह है कि यह चेतावनी क्यों है? क्या टूट सकता है / हो सकता है? क्या मैं किसी एलएलटी (लंबे समय तक जीवित लेनदेन) का उपयोग करने में सक्षम नहीं हूं?

यदि एलएलटी ठीक है। इस मुद्दे को संभालने के लिए सबसे अच्छा तरीका क्या होगा? AlarmManager समय का विस्तार?

अग्रिम में धन्यवाद ;)

मुझे @sospedra के समान ही समस्या आ रही है। मैं redux-saga का उपयोग कर रहा हूं और मेरे पास एक ऐसी गाथा है जो पृष्ठभूमि में हर 3 मिनट में ऐप के कुछ डेटा को ताज़ा करती है, इसलिए गाथा में yield call(delay, 3 * 60000); का कोड शामिल है। परिणामस्वरूप मुझे यह "समय की लंबी अवधि के लिए टाइमर सेट करना ..." त्रुटि मिल रही है।

मैं यह भी सोच रहा हूं कि सुझाए गए दृष्टिकोण इस तरह से क्या है। अगर मैं अपना कोड इस तरह से काम करना छोड़ दूं तो मुझे क्या समस्या होगी? त्रुटि संदेश का अर्थ है कि प्रदर्शन के मुद्दे हो सकते हैं, और शायद यह कि टाइमर वास्तव में सही समय पर निकाल नहीं दिया जाएगा यदि ऐप पृष्ठभूमि में है?

यदि 3 मिनट टाइमर सेट करने वाले इस कोड के साथ समस्याएं होने की संभावना है, तो क्या वैकल्पिक समाधान समान कार्यक्षमता प्राप्त करेगा और इन समस्याओं में नहीं चलेगा?

अभी भी एक ही मुद्दा हो रहा है।

मुझे लगता है, इसका एकमात्र समाधान मूल निवासी Android विकास है

समस्या अभी भी हल नहीं हो सकती है? किसी को भी हल मिल गया?

फायरबेस का इस्तेमाल करते हुए मुझे चेतावनी मिल रही है।

यदि समस्या किसी तीसरे पक्ष के पुस्तकालय से नहीं है, लेकिन आप स्वयं से एक लंबा समय निर्धारित करते हैं, तो प्रतिक्रिया-मूल-पृष्ठभूमि-टाइमर लाइब्रेरी का उपयोग करने के लिए एक अच्छा समाधान है। यह README में एक सरल उदाहरण है।

दुर्भाग्य से , यदि यह मुद्दा किसी तीसरे पक्ष के पुस्तकालय से है, तो आपके पास संभवतः कोई समाधान नहीं है कि उस स्थान को खोजने के लिए जहां सेटटाइमआउट कहा जाता है और एक मुद्दा उठाएं / इसके बजाय उपरोक्त पुस्तकालय का उपयोग करने के लिए पीआर सबमिट करें , कृपया नीचे दिए गए मेरे संभावित समाधान का प्रयास करें। https://github.com/facebook/react-native/issues/12981#issuecomment -331074444 और कोशिश करें कि यह आपके लिए काम करे।

कृपया Android पर भी शानदार टाइमआउट करें।

जैसा कि @SuhairZain ने कहा है कि प्रतिक्रिया-मूल-पृष्ठभूमि-टाइमर एक अच्छा समाधान है। यह चेतावनी को साफ कर सकता है

सॉकेट का उपयोग करते समय मुझे यह चेतावनी मिल रही है

क्योंकि socket.io में 85ms का टाइमर है

FWIW यह केवल मेरे लिए होता है जब मैं विकसित करते समय Reactotron का उपयोग करता हूं ...

मुझे कुछ समय के लिए पागल होना पड़ा, लेकिन मुझे पता था कि मैं संदेश को अनदेखा नहीं कर सकता

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

import BackgroundTimer from 'react-native-background-timer';

setTimeout = BackgroundTimer.setTimeout;
setInterval = BackgroundTimer.setInterval;
clearTimeout = BackgroundTimer.clearTimeout;
clearInterval = BackgroundTimer.clearInterval;

इस कोड को अपने शुरुआती इनिशियलाइज़ेशन में कहीं लिखिए, अधिमानतः index.android.js या index.ios.js सबसे पहले उस स्थान पर जहाँ आप कर सकते हैं। अगर कोई इसका परीक्षण कर सकता है, तो उसे बहुत सराहना मिलेगी।

@SuhairZain : आपका सुझाव अभी तक मेरे लिए काम कर रहा है, कुछ

setTimeout = BackgroundTimer.setTimeout.bind(BackgroundTimer)
setInterval = BackgroundTimer.setInterval.bind(BackgroundTimer)
clearTimeout = BackgroundTimer.clearTimeout.bind(BackgroundTimer)
clearInterval = BackgroundTimer.clearInterval.bind(BackgroundTimer)

@ प्रासंगिकता मैंने आपका कोड मेरे app.js में जोड़ दिया, लेकिन मुझे यह मिल गया

अपरिभाषित कोई वस्तु नहीं है ('RNBackgroundTimer.setTimeout' का मूल्यांकन)

@realtebo लगता है कि आपने प्रतिक्रिया-मूल-पृष्ठभूमि-टाइमर की स्थापना पूरी नहीं की होगी, जैसा कि उनके README में वर्णित है, react-native link चलाकर या कोकोपोड्स का उपयोग करके।

@ ऊंचाई : क्या आप react-native link चलने का मतलब है?

npm स्थापित -g प्रतिक्रिया-देशी-क्ली
प्रतिक्रिया-मूल लिंक
C: \ Users \ Realtebo \ Downloads \ Manager2 \ node_modules (54ms) में सीमलिंक के लिए फ़ोल्डर्स को स्कैन करना
react-native link क्रिएट रिएक्टिव नेटिव ऐप प्रोजेक्ट्स में उपयोग नहीं किए जा सकते। यदि आपको एक पुस्तकालय शामिल करने की आवश्यकता है जो कस्टम देशी कोड पर निर्भर करता है, तो आपको पहले अस्वीकार करना पड़ सकता है। अधिक जानकारी के लिए https://github.com/react-community/create-react-native-app/blob/master/EJECTING.md देखें।

मैं अस्वीकार नहीं करना चाहता .... इसलिए, .. मैं क्या कर सकता हूं?

ओह, क्षमा करें, मुझे पता नहीं है कि कैसे एक रिएक्टिव नेटिव ऐप प्रोजेक्ट बनाएं। मैंने कभी खुद का इस्तेमाल नहीं किया है।

नमस्ते,
मुझे react-native: ^0.49.3 साथ कुछ मुद्दे मिले ...

सीएफ https://github.com/ocetnik/react-native-background-timer/issues/65

आशा है कि आप मदद कर सकते हैं, आपके समय के लिए धन्यवाद;)

नमस्ते, मेरे पास एक ही मुद्दा है मैं 0.49 का उपयोग कर रहा हूं, यह ऐसा करने के बाद दिखाई दिया

export function saveUserData(userInfo){
  return (dispatch) => {
    dispatch(saveDataRequest())
    const userId = firebase.auth().currentUser.uid;
    return firebase.database().ref('users/' + userId).set(userInfo)
      .then(() => {
        dispatch(saveDataSuccess());
        dispatch(NavigationActions.navigate({ routeName: 'TabContactNavigation' }))
      })
      .catch((error) => {
        dispatch(saveDataFailure(error))
      });
  }
}

ऊपर Action redux में है, जो redux-thunk का भी उपयोग करता है .. जब एक बटन पर क्लिक करके डेटा को firebase में सहेजने के लिए क्लिक किया जाता है, तो सफल होने पर इसे saveDataSuccess() भेजा जाता है
अब मुझे यहाँ const userId = firebase.auth().currentUser.uid दिखाई देने की समस्या पर संदेह हो रहा है लेकिन मुझे यकीन नहीं है। यहाँ समस्या का एक स्क्रीन शॉट है। (एप्लिकेशन ठीक काम करता है, लेकिन यह चेतावनी दिखाई देती है, मुझे नहीं पता कि क्या मुझे इसे अनदेखा करना चाहिए) या शायद मैं यहां कुछ गलत कर रहा हूं, आपके मदद की जरूरत है, धन्यवाद

अरे, चेतावनी सेटटाइमआउट के बारे में है क्या आप इसे अपने घटक में उपयोग कर रहे हैं?
और हाँ, लाइन कास्ट userId = firebase.auth ()। currentUser.uid; काम नहीं कर रहा है, यह एक वादा है और जब आप उपयोगकर्ता का उपयोग करते हैं तो यह अभी भी नहीं आ रहा है।
यह करने के लिए एक बेहतर तरीका है कि उपयोगकर्ता को एक्शन क्रिएटर से प्राप्त करें, आप पहले से ही userInfo चर भेज रहे हैं, इसके लिए प्रयास करें:

मैं मान लूंगा की तुलना में userInfo फायरबेस ऑरिजनल लॉगिन से आ रहा है, इसलिए आपके पास इसमें यूआईडी है

निर्यात समारोह saveUserData (userInfo) {
वापसी (प्रेषण) => {
प्रेषण (saveDataRequest ())
// const userId = firebase.auth ()। currentUser.uid;
वापसी firebase.database ()। Ref ('उपयोगकर्ता /' + userInfo.uid) .set (userInfo)
.then () => {
प्रेषण (saveDataSuccess ());
प्रेषण (नेविगेशनएक्टेशन.नवेट ({मार्गनाम: ont TabContactNavigation ’}))
})
.कच ((त्रुटि) => {
प्रेषण (saveDataFailure (त्रुटि))
});
}
}
मुझे आशा है कि यह मदद कर सकता है, और मेरे बुरे अंग्रेजी = पी के लिए खेद है

परमानंद

एल 23/10/2017, एक लास 23:59, यासिर नोटिफिकेशन @github.com escribió:

नमस्ते, मेरे पास एक ही मुद्दा है जिसका मैं 0.49 उपयोग कर रहा हूं, यह ऐसा करने के बाद दिखाई दिया

निर्यात समारोह saveUserData (userInfo) {
वापसी (प्रेषण) => {
प्रेषण (saveDataRequest ())
const userId = firebase.auth ()। currentUser.uid;
वापसी firebase.database ()। Ref। ('उपयोगकर्ता /' + userId) .set (userInfo)
.then () => {
प्रेषण (saveDataSuccess ());
प्रेषण (नेविगेशनएक्टेशन.नवेट ({मार्गनाम: ont TabContactNavigation ’}))
})
.कच ((त्रुटि) => {
प्रेषण (saveDataFailure (त्रुटि))
});
}
}
ऊपर एक्शन इन रेडक्स है, जिसमें रेडक्स-थंक का भी उपयोग किया गया है। जब एक बटन को क्लिक करने पर डेटा को फायरबेस से बचाने के लिए क्लिक किया जाता है, तो सफल होने पर इसे सेव करेंDataSuccess () और फिर अगले टैब पर नेविगेट करें।
अब मुझे समस्या का संदेह हो रहा है कि यहाँ पर userId = firebase.auth () currentUser.uid हो, लेकिन मुझे यकीन नहीं है। यहाँ समस्या का एक स्क्रीन शॉट है। (एप्लिकेशन ठीक काम करता है, लेकिन यह चेतावनी दिखाई देती है, मुझे नहीं पता कि क्या मुझे इसे अनदेखा करना चाहिए) या शायद मैं यहां कुछ गलत कर रहा हूं, आपके मदद की जरूरत है, धन्यवाद

https://user-images.githubusercontent.com/12644122/31925375-94b7c464-b89d-11e7-889d-e9d00866ff73.png
https://user-images.githubusercontent.com/12644122/31925386-9e9bf3c4-b89d-11e7-9eaa-65147879629f.png
-
आप इसे प्राप्त कर रहे हैं क्योंकि आपको इस धागे की सदस्यता दी गई है।
इस ईमेल का उत्तर सीधे दें, इसे GitHub https://github.com/facebook/react-native/issues/12981#issuecomment-338874018 पर https://github.com/nactions/unsubscribe-auth/ पर म्यूट

आमतौर पर मैं एक redux स्टोर में सेव करता हूं userinfo।
इसलिए मैं बस जरूरत के अनुसार मना करता हूं।
... लेकिन ... एक समान स्थिति में, मैं टाइमआउट के साथ समान समस्या है

प्रतिक्रिया-देशी-सिग्नल-लाइब्रेरी (300000ms) के साथ एक ही मुद्दा

socket.io सर्वर विकल्प
pingTimeout (60000) + pingInterval (25000) <= 60000

एंड्रॉइड पर हमें इससे कैसे निपटना चाहिए, इस पर कोई अपडेट? अभी भी इसे प्राप्त कर रहा है, सेटटाइमआउट का उपयोग नहीं कर रहा है ...

बस अपनी पिछली टिप्पणी (अगस्त से) का पालन करने के लिए, जिसे मैं अपने आसपास के सभी लोगों की भावनाओं पर विश्वास करता हूं: हम इस अलार्म मैन के साथ ठीक हैं, बस इतना है कि हम लंबे समय तक लेन-देन को संभालने के लिए सबसे अच्छा

cc @shergin @cpojer @javache @hramos

एंड्रॉइड पर प्रतिक्रिया-देशी-सिग्नल (एमएस-सिग्नलर-क्लाइंट) के लिए एक तयशुदा डिफ़ॉल्ट पिंगेरेंथवल (300000) है:
connection.start({ pingInterval: 5000, jsonp: true, transport: ['webSockets', 'serverSentEvents', 'longPolling']}).done(() => { console.log('Now connected, connection ID =' + connection.id) })

प्रतिक्रिया-मूल-पोमेलो (80000ms) के साथ एक ही मुद्दा

console.ignoredYellowBox = ['Setting a timer'];

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

कंसोल को इग्नोर कोड डालने के लिए वास्तव में सबसे अच्छी जगह कहां है? '

- कोई बात नहीं, लिंक किए गए संकेत मिला stackexchange इस प्रकार, मेरे App.js को जोड़ा गया:

class App extends Component {
  constructor() {
    super();

    console.ignoredYellowBox = [
      'Setting a timer'
    ];
  }
...
}
````

and also tried in my index.js as <strong i="8">@haikyuu</strong> just recommended..

'प्रतिक्रिया-मूलक' से आयात {AppRegistry};
से आयात ऐप './App';

कंसोल .ignoredYellowBox = [
'एक टाइमर की स्थापना'
];

AppRegistry.registerComponent ('manager', () => App);
`` ``

दोनों में काम किया

@CopyJosh आप इसे अपनी प्रविष्टि फ़ाइल में रख सकते हैं: index.js

इसलिए अभी तक इसका कोई वास्तविक समाधान नहीं है? अब 8+ महीने हो गए हैं।

?

चलो यह तो हल हो। हमें शायद यह पता लगाना होगा:

ए) एक आसान एक्स्टेंसिबल एपीआई जिसे रिएक्ट कोड के माध्यम से बुलाया जा सकता है। मुझे लगता है कि यह काम करने के लिए सिर्फ एक AlarmManagers तरीकों से निपटने के लिए बुद्धिमान होगा। उदाहरण के लिए, आपके रिएक्ट नेटिव कोड में निम्न विधि को कॉल करने से एंड्रॉइड डिवाइस देशी अलार्म मैनजर के साथ एक अलार्म सेट हो जाएगा।
AlarmMgr.setInexactRepeating(arg1, arg2...)

बी) यह काम करने के लिए वास्तविक कार्यान्वयन। जहाँ तक मुझे पता है, AlarmManager के साथ एक अलार्म सेट करना जो कि AlarmManager सेवा के लिए "लंबित आशय" कहलाता है। आप अलार्ममैन को बताते हैं कि आप भविष्य में किसी प्रकार के "कार्य" को अंजाम देना चाहेंगे। यह मुझे लगता है, कि आपको अलार्म मैनजर (या एक कस्टम रिएक्ट जावा विधि) करने की आवश्यकता होगी, अपने जावास्क्रिप्ट कोड में कुछ प्रकार के डेटा वापस भेजें, यह बताएं कि अलार्म बंद होने के बाद किस कोड को निष्पादित करना है।

किसी को भी इस समस्या से निपटने के लिए? अधिक यहाँ AlarmManager पर पढ़ा जा सकता

btw - क्या यह अक्षमता (लंबे, बहु-मिनट के समय से संबंधित) आरएन संस्करणों के लिए एक नया मुद्दा है> 0.43? या यह सिर्फ यह है कि चेतावनी को आरएन> 0.43 से थूक दिया जा रहा है? मैंने 0.43.x से 0.47.x पर माइग्रेट किया और चेतावनी देखना शुरू कर दिया। मैंने मान लिया कि अक्षमता हमेशा से रही है, और आरएन ने अभी मुझे इसके बारे में चेतावनी देना शुरू कर दिया है।

हालांकि, कुछ दिनों पहले प्रवास के बाद से, मैंने यह भी देखा कि मेरा ऐप मेरे फोन पर बहुत अधिक बैटरी की खपत कर रहा है! (और अंतर में अन्य विशेषताएं स्पष्ट अपराधी नहीं हैं)

अरे @astreet , क्या आपको शायद अब भी याद है कि आप क्या था कि इस मुद्दे को पोस्ट करते समय और इस चेतावनी को यहां जोड़ने पर जिक्र कर रहे थे https://github.com/facebook/react-native/commit/3637bce479 ?

यह हाल ही में मेरे लिए काफी कष्टप्रद हो गया है क्योंकि मैंने एक लीब का उपयोग करना शुरू कर दिया है जो 2min आवर्ती टाइमर सेट करता है इसलिए मैंने यह समझने के लिए खुदाई करना शुरू कर दिया कि इस चेतावनी को पहले स्थान पर क्यों जोड़ा गया है।

अब मैं इस वाक्य के बारे में चिंतित हूँ: "टाइमिंग मॉड्यूल जागृत रहता है"। मुझे लगता है कि आप यह कह सकते हैं कि टाइमर मॉड्यूल कोरियोग्राफर कॉलबैक सेट कर रहा है। हालांकि कॉलबैक की परवाह किए बिना लगता है कि हमारे पास टाइमर है या नहीं। प्रासंगिक कोड हिस्सा यहाँ देखें: https://github.com/facebook/react-native/blob/1e8f3b11027fe0a7514b4fc97d0798d3c64bc895/RctctAndroid/src/main/java/com/facebook/react/modules/core/Todules
कॉलमर को रोकने के लिए कोई कोड नहीं है जब कोई टाइमर शेड्यूल नहीं हैं और टाइमर के जुड़ने पर शेड्यूलिंग शुरू करने के लिए कोई कोड नहीं है। कॉलबैक केवल तभी निलंबित होता है जब ऐप बैकग्राउंड में चला जाता है और जब बैकग्राउंड में वापस चला जाता है तो रिस्टोर हो जाता है।

परिणामस्वरूप कोरियोग्राफर कॉलबैक की परवाह किए बिना अगर हम एक लंबी अवधि के लिए एक टाइमर, छोटी अवधि या सभी सेट पर कोई टाइमर के बिना प्रत्येक फ्रेम के लिए enqueued है। मैं यह नहीं देखता कि लंबे टाइमर की स्थापना उस स्थिति में प्रदर्शन को कैसे प्रभावित कर सकती है। तो क्या इसका मतलब यह है कि चेतावनी आवश्यक नहीं है?

जहां तक ​​लंबे टाइमर को "शुद्धता का मुद्दा" स्थापित करने की बात है, तो मुझे लगता है कि आप इस तथ्य का उल्लेख कर रहे हैं कि टाइमर केवल अग्रभूमि ऐप स्थिति में कॉल किए जाएंगे (इसलिए जब आप इसे भविष्य में कुछ लंबे समय के लिए सेट करते हैं और ऐप bg में चला जाता है यह या तो निष्पादित नहीं करेगा, या निष्पादित करेगा जब एप्लिकेशन अग्रभूमि में हो जाता है जो बाद में काफी हो सकता है जो आप उम्मीद करेंगे)। हालांकि मेरा मानना ​​है कि यह iOS के लिए एक ही मामला है जहां हम चेतावनी नहीं दिखाते हैं

सॉकेट में। डिफ़ॉल्ट पिंग लूप 85000ms, = pingInterval (25000ms) + pingTimeout (60000ms) है। और आपको सर्वर में उन विकल्पों को रीसेट करना चाहिए और pingInterval और pingTimeout <= 60000ms का योग सुनिश्चित करना चाहिए।

उदाहरण के लिए:

var socket = require('socket.io')(12345, {
  pingInterval: 20000, 
  pingTimeout: 40000
})

बस जिज्ञासु - मुझे अपने ऐप में लगभग 5 मिनट का समय निर्धारित करने में सक्षम होना चाहिए। यह मुद्दा कितना गंभीर है और यह मुझे कितना प्रभावित करेगा?

@ntomallen अगर ऐप हर समय ऑन-स्क्रीन रहेगा, तो कुछ भी नहीं बदलेगा। यह आसानी से काम करेगा। अन्यथा, शायद यह 5 मिनट के अंत में ट्रिगर नहीं होगा। या यह अस्पष्ट रूप से करेंगे।

मैं एंड्रॉइड चेंज सॉकेट सर्वर विकल्प pingTimeout 30000 पर रिएक्टिव नेटिव के साथ लार्वा इको का उपयोग करता हूं। यह काम करता है

@ सोस्फेदरा गोत्र मुझे यह सुनिश्चित करने के लिए कुछ परीक्षण करना होगा कि यह बहुत बुरा नहीं है!

क्या हमेशा हैंडलर.पोस्टडेलयेड का उपयोग नहीं करने का कोई कारण है?

इस मुद्दे के लिए कोई जल्दी ठीक? मैंने अभी आरएन का उपयोग फायरबेस के साथ करना शुरू किया।

मैंने कुछ अलग-अलग टाइमर समाधानों की कोशिश की है, लेकिन पृष्ठभूमि (लगातार) में काम करने का कोई सौभाग्य नहीं मिला है।

मैंने हर 10 मिनट में अपने सर्वर को पिंग करने के लिए एक setInterval का उपयोग किया है - मैंने सिर्फ इस त्रुटि संदेश को देखा क्योंकि मैं setInterval(myFunction, 60000) करता हूं। क्या यह कुछ है जिसके बारे में मुझे चिंतित होने की आवश्यकता है?

मेरा अपेक्षित व्यवहार यह है कि ऐप के खुले रहने पर, यह अनुरोधों को बंद कर सकता है, लेकिन ऐप के निलंबित होने के बाद (एकल होम बटन प्रेस) अनुरोधों को बंद कर देना चाहिए। क्या यह व्यवहार है जो मैं उम्मीद कर सकता हूं, और क्या एप्लिकेशन निलंबित होने पर बैटरी जीवन प्रभावित होगा?

यहां चिंता की कोई बात नहीं है, और चेतावनी गलत है और इसे हटा दिया जाना चाहिए। जागृत रखने के लिए "टाइमिंग मॉड्यूल" नहीं है, बस एक कोरियोग्राफर कॉलबैक है जो टाइमर के लिए हर फ्रेम की जांच करता है (जो टाइमर के लिए मिन ग्रैन्युलैरिटी ~ 16ms करता है)।

इस अर्थ में एक शुद्धता मुद्दा है कि टाइमर या एंड्रॉइड पर पृष्ठभूमि में आग नहीं लगेगी। यह चेतावनी विशेष रूप से Android के बारे में प्रतीत होती है, हालांकि सटीक प्रतीत नहीं होती है। ऐप के अग्रभूमि में वापस आने पर सभी टाइमर को अंततः फायर करना चाहिए।

इसे जल्द ही संबोधित करने पर कोई योजना? जब भी हम एंड्रॉइड फोन पर परीक्षण कर रहे हैं, तो लॉग इन कष्टप्रद है।

मेरी समस्या…

मुझे यह त्रुटि मिल रही थी क्योंकि मेरा टाइमआउट ~ 59 मिनट तक था। कोड घंटे के शीर्ष पर एक विधि कॉल और था करने के लिए एक setTimeout बनाने के लिए एक setInterval घंटे के अगले शीर्ष पर।

मेरा समाधान…

1. setTimeout को मिनट के शीर्ष पर setInterval शुरू करने के लिए अपडेट करें।
2. यदि वर्तमान मिनट 0 था, तो केवल फ़ंक्शन चलाने के लिए setInterval नामक फ़ंक्शन को अपडेट करें।

यह फ़ंक्शन अब हर घंटे के बजाय हर मिनट चलता है ... लेकिन चूंकि यह 60 में से 59 बार कुछ भी नहीं करता है, हानिरहित लगता है।

हे @beammith , यह वास्तव में केवल 60 टाइमर सेट करने के लिए एक समाधान है? मेरी समझ में, यह अभी भी टाइमरमॉड्यूल को एक ही घंटे के लिए सक्रिय रख रहा है, लेकिन चेतावनी नहीं दिखा रहा है :)

@newah - हाँ, यह थोड़ा

@beausmith , मैंने https://github.com/ocetnik/react-native-background-timer का उपयोग करने की कोशिश की, जो देशी टाइमर का उपयोग करता है, जो एक समाधान की तरह लगता है - मैंने इस परिवाद के कार्यान्वयन के लिए सेटटिमआउट और सेटइंटरवल ओवरराइट कर दिया है।

पृष्ठभूमि में सहायक टाइमर आपकी आवश्यकताओं के आधार पर प्लस या माइनस हो सकते हैं :))

ठीक काम करने लगता है, लेकिन मेरी समस्याओं को हल नहीं किया :)

अगर मैं प्रतिक्रिया-intl FormattedRelative का उपयोग करता हूं तो मेरे पास एक ही चेतावनी है। क्योंकि अंदर घटक FormattedRelative टाइमर का उपयोग किया जाता है:

scheduleNextUpdate(props, state) {
    // Cancel and pending update because we're scheduling a new update.
    clearTimeout(this._timer);

    const {value, units, updateInterval} = props;
    const time = new Date(value).getTime();

    // If the `updateInterval` is falsy, including `0` or we don't have a
    // valid date, then auto updates have been turned off, so we bail and
    // skip scheduling an update.
    if (!updateInterval || !isFinite(time)) {
      return;
    }

    const delta = time - state.now;
    const unitDelay = getUnitDelay(units || selectUnits(delta));
    const unitRemainder = Math.abs(delta % unitDelay);

    // We want the largest possible timer delay which will still display
    // accurate information while reducing unnecessary re-renders. The delay
    // should be until the next "interesting" moment, like a tick from
    // "1 minute ago" to "2 minutes ago" when the delta is 120,000ms.
    const delay =
      delta < 0
        ? Math.max(updateInterval, unitDelay - unitRemainder)
        : Math.max(updateInterval, unitRemainder);

    this._timer = setTimeout(() => {
      this.setState({now: this.context.intl.now()});
    }, delay);
  }

यहाँ मेरे कोड में उपयोग का उदाहरण है:

<FormattedRelative value={date}>
    {(message: string) => <Text>{message}</Text>}
</FormattedRelative>

किसी को पता है कि इस चेतावनी को कैसे ठीक करें?

यह अभी भी एक मुद्दा है। Android पर फायरबेस सेवाओं का उपयोग करते समय यह विशेष रूप से कष्टप्रद है। कृपया ठीक करें।

यह फायरबेस सेवाओं के लिए एक बहुत बुरा बग है और जब आप तीसरे भाग के ऐप पर निर्भर होते हैं। क्योंकि अगर आप इस प्रक्रिया को जारी रखने के लिए कुछ को सत्यापित करने के लिए ऐप्स के बीच स्विच करते हैं तो फायरबेस काम नहीं करता है।

एक उदाहरण है कि हम एक थर्डपार्टी / फैक्टर लॉगिन सिस्टम का उपयोग करते हैं, और टोकन को स्थानांतरित करने के लिए फायरबेस का उपयोग करते हैं। लेकिन जब से हम टोकन साफ ​​करते हैं, उस व्यक्ति के वापस जाने से पहले हमारे ऐप में वापस आ जाता है। इसलिए मैं क्लीनअप मैकेनिज्म को बदल सकता हूं, या आप लोग इस बग को ठीक कर सकते हैं।

@vongohren नहीं है कि मैं आपके उपयोग के मामले को पूरी तरह से समझता हूं, लेकिन एक वर्कअराउंड रणनीति पृष्ठभूमि में प्रवेश पर आपके ऐप के भीतर पृष्ठभूमि की तारीख को संग्रहीत करने के लिए हो सकती है, फिर अग्रभूमि पर लौटने पर संग्रहीत पृष्ठभूमि की तारीख के साथ वर्तमान तिथि की तुलना करें और अपना क्लीनअप करें यदि एक निश्चित समय अवधि बीत गई है ...

मेरे उपयोग के मामले पर विस्तार से बताने के लिए। कहें कि आप लॉगिन स्वीकार करने के लिए किसी अन्य ऐप में हां कहने पर निर्भर हैं। किसी थर्ड पार्टी में लॉगइन रिक्वेस्ट के लिए हां कहने के लिए फेक फेसबुक एप पर स्विच करते हैं। के साथ काम करने वाला ठोस उदाहरण uPort, https://www.uport.me/ है। फिर जब हम अपने ऐप को संदेश देने के तरीके पर भरोसा करते हैं, तो अब यह कहने के लिए पृष्ठभूमि में कि यह सब अच्छा है, यह फ़ायरबेश के साथ काम नहीं करता है जब तक कि हम आपके दृष्टिकोण को बाद के बिंदु पर साफ करने के लिए नहीं लेते।

मुझे लगता है कि मैं सिर्फ इस बात पर अटका हुआ था कि उत्सर्जित सूचना के बाद सफाई ठीक हो सकती है, क्योंकि तब सूचना पहले से ही उत्सर्जित हो गई थी, और हमें इसकी आवश्यकता नहीं होगी। लेकिन ऐसा क्यों है कि प्रतिक्रिया में देशी में फायरबेस दृष्टिकोण काम नहीं करता है? यह अपने पृष्ठभूमि के कार्यकर्ताओं को रोकता है।

मुझे अपने ऐप में 30 मिनट का टाइमआउट चाहिए। हर बार उपयोगकर्ता के पास स्क्रीन के साथ इंटरैक्शन होगा जो इसे रीसेट करेगा (पुराने टाइमआउट को हटा दें, नया बनाएं)।

यह कैसे सही तरीके से करने के लिए कोई विकल्प? क्या देशी कोड के साथ इसे संभालना और प्रतिक्रिया समाप्त होने पर कुछ पास करना बेहतर है?

वाह, तो यह अभी भी एक मुद्दा है

@nbennink यहाँ उत्तर की जाँच

सॉकेट के उपयोग के बाद मुझे भी चेतावनी मिल रही है।
चेतावनी नीचे है:

Setting a timer for a long period of time, i.e. multiple minutes, is a performance and correctness issue on Android as it keeps the timer module awake, and timers can only be called when the app is in the foreground. See https://github.com/facebook/react-native/issues/12981 for more info.
(Saw setTimeout with duration 85000ms)

मेरा पैकेज विवरण नीचे है:

• "प्रतिक्रिया": "^ 16.3.0-अल्फा.1",
• "प्रतिक्रिया-मूलक": "0.54.4",
• "सॉकेट.आईओ": "^ 2.1.1",
• "सॉकेट.-क्लाइंट": "^ 2.1.1",

किसी भी स्थायी समाधान का पता लगाएं?

सॉकेट के उपयोग के बाद मुझे भी चेतावनी मिल रही है।
चेतावनी नीचे है:

Setting a timer for a long period of time, i.e. multiple minutes, is a performance and correctness issue on Android as it keeps the timer module awake, and timers can only be called when the app is in the foreground. See https://github.com/facebook/react-native/issues/12981 for more info.
(Saw setTimeout with duration 85000ms)

मेरा पैकेज विवरण नीचे है:

"प्रतिक्रिया": "^ 16.3.0-अल्फा.1",
"प्रतिक्रिया-मूलक": "0.54.4",
"सॉकेट.आईओ": "^ 2.1.1",
"सॉकेट.-क्लाइंट": "^ 2.1.1",

किसी भी स्थायी समाधान का पता लगाएं?

Ditto, इस के आसपास जाने का कोई रास्ता नहीं है?

अभी भी प्रतिक्रिया-मूल 0.57 पर यह चेतावनी मिल रही है, क्या यह मुद्दा इसके बजाय खुला होना चाहिए?

लगभग एक साल और प्रतिक्रिया मूल निवासी अभी भी एक ही मुद्दा है !!!

एक ही मुद्दे का सामना करते हुए, एक ही चेतावनी 3-4 बार दिखाई देती है। बहुत कष्टप्रद।

क्या इस मुद्दे को हल करने के लिए कोई समाधान है?

इस समाधान के द्वारा चेतावनी संदेश से छुटकारा पाएं https://stackoverflow.com/a/48778011/7427111

यह मूल रूप से सिर्फ संदेश छिपा रहा है समस्या को ठीक नहीं कर रहा है, मुझे लगता है।

@dhavaljardosh हां, आपका अनुमान सही है।

मैंने जावा और ऑब्जेक्टिव सी के साथ एक देशी टाइमर बनाया। यह मेरे लिए काम करता है और यह संदेश छिपाता है। मुझे यकीन नहीं है कि यह वास्तव में प्रदर्शन में सुधार करता है। जैसा कि ऊपर उल्लेख किया गया है: यह बैटरी आदि के लिए अभी भी खराब है क्योंकि पृष्ठभूमि में एक लंबा टाइमर है।

पूछने के लिए एक प्रश्न यह है कि क्या आपको वास्तव में मतदान कार्य की आवश्यकता है। मुझे लगा कि मैंने किया है, लेकिन फिर इस मुद्दे के कारण, मुझे एहसास हुआ कि मुझे केवल _some_ अर्ध-लगातार समय पर निष्पादित करने की आवश्यकता है। इसलिए अब मैं इसे ऐप बैकग्राउंड पर चला रहा हूं और पूरी तरह से इस मुद्दे से बच रहा हूं। YMMV।

पुशर का उपयोग करते समय एक ही समस्या ...

मैं हर 60 सेकंड में एक टाइमर सेट करते समय प्रदर्शन प्रभाव क्या है, यह देखने के लिए मैं अपने ऐप का परीक्षण करूंगा।
हालाँकि, मुझे लगता है कि आप में से कुछ के साथ अनुभव है। क्या आप इस अनुभव को साझा कर सकते हैं, कृपया क्या प्रभाव महत्वपूर्ण है?

अभी भी नवीनतम संस्करण के साथ एक ही मुद्दा।
कोई भी समाधान?

मैं उस मुद्दे का भी सामना कर रहा हूं।
एप्लिकेशन ठीक काम कर रहा था, यह केवल तभी है जब मैंने फायरबेस का उपयोग शुरू कर दिया था कि चेतावनी आई थी।
कोई भी समाधान?

मैं इस संदेश के पीछे के अर्थ को समझना चाहता हूं क्योंकि हमने हाल ही में हमारे उत्पाद में जोड़े गए एक फीचर के बाद इसे प्राप्त करना शुरू कर दिया है। क्या समस्या _only_ इस तथ्य के साथ है कि ऐप को पृष्ठभूमि में रखते हुए टाइमर चल रहा है? क्या ऐप राज्य की घटनाओं को सब्सक्राइब करना और ऐप को बैकग्राउंड करने पर टाइमर को बंद करना एक उचित समाधान होगा? या _foreground_ समस्याग्रस्त में भी ऐप के साथ एक लंबे समय से चल रहा टाइमर है?

मैं इस संदेश के पीछे के अर्थ को समझना चाहता हूं क्योंकि हमने हाल ही में हमारे उत्पाद में जोड़े गए एक फीचर के बाद इसे प्राप्त करना शुरू कर दिया है। क्या समस्या _only_ इस तथ्य के साथ है कि ऐप को पृष्ठभूमि में रखते हुए टाइमर चल रहा है? क्या ऐप राज्य की घटनाओं को सब्सक्राइब करना और ऐप को बैकग्राउंड करने पर टाइमर को बंद करना एक उचित समाधान होगा? या _foreground_ समस्याग्रस्त में भी ऐप के साथ एक लंबे समय से चल रहा टाइमर है?

इसे भी जानना चाहेंगे।

इसके अलावा, setInterval के साथ क्या होता है? मैं इस एक से चेतावनी नहीं मिलता है, लेकिन यह एक ही मुद्दा है?

मैं इस संदेश के पीछे के अर्थ को समझना चाहता हूं क्योंकि हमने हाल ही में हमारे उत्पाद में जोड़े गए एक फीचर के बाद इसे प्राप्त करना शुरू कर दिया है। क्या समस्या _only_ इस तथ्य के साथ है कि ऐप को पृष्ठभूमि में रखते हुए टाइमर चल रहा है? क्या ऐप राज्य की घटनाओं को सब्सक्राइब करना और ऐप को बैकग्राउंड करने पर टाइमर को बंद करना एक उचित समाधान होगा? या _foreground_ समस्याग्रस्त में भी ऐप के साथ एक लंबे समय से चल रहा टाइमर है?

येलो मैसेज कहता है "... और टाइमर केवल तभी कहा जा सकता है जब ऐप अग्रभूमि में हो।"
टाइमर मॉड्यूल जागता रहता है, लेकिन जब ऐप पृष्ठभूमि में होता है तो टाइमर काम नहीं कर सकते? तो समस्या तब होती है जब ऐप के बैकग्राउंड में टाइमर मॉड्यूल को जागृत रखा जाता है? कितना अच्छा प्रदर्शन / बैटरी प्रभाव है कि मुझे आश्चर्य होगा ...

@BerndWessels https://www.npmjs.com/package/react-native-firebase क्या आपने इसे देखा है? कहते हैं, यह देशी धागे पर फायरबेस को चलाने की अनुमति देता है। यह निश्चित नहीं है कि यह कितना सच है, लेकिन देखने लायक हो सकता है। आप भी इसका उपयोग कर रहे होंगे, मुझे यकीन नहीं है।

क्या आपको लगता है कि अगर मैं इस लाइब्रेरी में जाता हूं तो मुझे अपना मौजूदा कोड बदलना होगा? मेरा मतलब है, यह बहुत अच्छा नहीं होगा ...

नवीनतम RN0.59 पर पुशर के साथ एक ही मुद्दा, और ui कुछ सेकंड अटक सकता है ...

मैं इस मुद्दे पर केवल तभी चलता हूं जब मैं फायरबेस के रियलटाइम डेटाबेस पर कॉल करता हूं।

await firebase.database().ref('users/' + id).set(data);

आरएन 0.57.1

मैंने 0.59 के साथ पुष्टि नहीं की है।

@swushi मुझे RN 0.59 साथ एक ही मुद्दा मिल रहा है

मुझे फायरबेस लाइब्रेरी का उपयोग करते हुए चेतावनी मिल रही है

Setting a timer for a long period of time, i.e. multiple minutes, is a performance and correctness issue on Android as it keeps the timer module awake, and timers can only be called when the app is in the foreground. See https://github.com/facebook/react-native/issues/12981 for more info. (Saw setTimeout with duration 111862ms)

इस चेतावनी से कैसे छुटकारा पाएं ...

क्या किसी को पता है कि इस चेतावनी को छुपाने के बिना कैसे छुटकारा पाएं ??
मैं firebase लाइब्रेरी का उपयोग प्रतिक्रिया-मूल-फायरबेस नहीं करता, लेकिन लगता है कि एक ही मुद्दा है और मुझे नहीं पता कि उत्पादन होने पर यह मुझे कैसे प्रभावित करेगा।

मैं वास्तव में चिंतित हूँ अगर कोई कृपया मदद कर सकता है ...

मैं इस समय (इस समय) को प्राप्त करने के लिए निम्नलिखित कोड का उपयोग कर रहा हूं:

https://github.com/firebase/firebase-js-sdk/issues/97#issuecomment -427512040 देखें

fixtimerbug.js

/////////////////////////////////////////////////////////////////////////////
////// temporary fix to bug about 'Setting a timer' /////////////////////////
////// See: https://github.com/pusher/pusher-js/issues/248 //////////////////
////// See: https://github.com/facebook/react-native/issues/12981 ///////////
////// See: https://github.com/firebase/firebase-js-sdk/issues/97 ///////////
/////////////////////////////////////////////////////////////////////////////
import { Platform, InteractionManager } from 'react-native';
const _setTimeout = global.setTimeout;
const _clearTimeout = global.clearTimeout;
const MAX_TIMER_DURATION_MS = 60 * 1000;
if (Platform.OS === 'android') {
  const timerFix = {};
  const runTask = (id, fn, ttl, args) => {
    const waitingTime = ttl - Date.now();
    if (waitingTime <= 1) {
      InteractionManager.runAfterInteractions(() => {
        if (!timerFix[id]) {
          return;
        }
        delete timerFix[id];
        fn(...args);
      });
      return;
    }
    const afterTime = Math.min(waitingTime, MAX_TIMER_DURATION_MS);
    timerFix[id] = _setTimeout(() => runTask(id, fn, ttl, args), afterTime);
  };
  global.setTimeout = (fn, time, ...args) => {
    if (MAX_TIMER_DURATION_MS < time) {
      const ttl = Date.now() + time;
      const id = '_lt_' + Object.keys(timerFix).length;
      runTask(id, fn, ttl, args);
      return id;
    }
    return _setTimeout(fn, time, ...args);
  };
  global.clearTimeout = id => {
    if (typeof id === 'string' && id.startsWith('_lt_')) {
      _clearTimeout(timerFix[id]);
      delete timerFix[id];
      return;
    }
    _clearTimeout(id);
  };
}
/////////////////////////////////////////////////////////////////////////////

@cpmech
आप इसे एक स्वतंत्र .js फ़ाइल में कार्यान्वित करते हैं, या आप इसे स्क्रिप्ट के अंदर करते हैं जो टाइमर अपवाद बनाता है

नमस्ते, हाँ ऊपर का कोड 'fixtimerbug.js' नामक फ़ाइल में जाता है। फिर, मैं इसे अपने App.js में लोड करता हूँ जैसे:

import './src/fixtimerbug'; // <<<<<<<<<<<<<<<<<<

import React from 'react';
import { Platform, View, StatusBar } from 'react-native';
import AppNavigator from './src/navigation/AppNavigator';
import Store from './src/model/Store';

const store = new Store();

const App = () => (
  <View style={{ flex: 1, backgroundColor: '#fff' }}>
    {Platform.OS === 'ios' && <StatusBar barStyle="default" />}
    <AppNavigator screenProps={{ store }} />
  </View>
);

export default App;

लगता है कि यह ठीक काम कर रहा है, यह क्या करता है?

थैंक यू यू मच @cpmech

हाय, कोड (यहाँ से: https://github.com/firebase/firebase-js-sdk/issues/97#issuecomment-427512040) बस setTimeout (वैश्विक) फ़ंक्शन से बचाता है ताकि इसे होने से रोका जा सके। एक लंबी अवधि के साथ प्रयोग किया जाता है।

हमारे संशोधित global.setTimeout फ़ंक्शन में, यदि अवधि समय सीमा MAX_TIMER_DURATION_MS , तो हम एक स्थानीय मानचित्र में id बचाते हैं ( timerFix ) और फिर runTask कॉल करें जो अवधि को छोटे मानों में विभाजित करता है। runTask एक टाइमआउट सेट करता है (मूल _setTimeout का उपयोग करके) छोटे चंक्स के साथ जो waitingTime बहुत छोटे होने तक लगातार निष्पादित होंगे। जब waitingTime काफी छोटा होता है, तो हम React Native के runAfterInteractions को एक सहज निष्पादन के लिए कहते हैं, और साथ ही, हम अपने स्थानीय मानचित्र से id प्रविष्टि निकालते हैं क्योंकि हम जीते थे इस मामले में _setTimeout फिर से कॉल न करें। ध्यान दें कि afterTime लंबी अवधि के साथ बुलाए जाने से रोकने के लिए _setTimeout में खिलाया जाता है।

अन्यथा, हमारे संशोधित global.setTimeout फ़ंक्शन में, यदि अवधि समय सीमा MAX_TIMER_DURATION_MS से छोटी है, तो हम सीधे वैश्विक सेटटाइमआउट ( _setTimeout में सहेजे गए) कहते हैं।

वैश्विक clearTimeout को स्थानीय मानचित्र से id हटाकर एक सफाई प्रक्रिया करने के लिए भी लपेटा जाता है।

आशा है कि इससे सहायता मिलेगी!

उसी मुद्दे का सामना करते हुए .. जैसा लगता है, हमें समय के लिए चेतावनी को छिपाना होगा। यहाँ यह करने का सबसे छोटा तरीका है:
componentDidMount() { console.disableYellowBox = true; ... }

नमस्ते, कोड (यहाँ से: firebase / firebase-js-sdk # 97 (टिप्पणी) ) केवल setTimeout (वैश्विक) फ़ंक्शन को लपेटता है ताकि इसे लंबे समय तक उपयोग करने से रोका जा सके।

हमारे संशोधित global.setTimeout फ़ंक्शन में, यदि अवधि समय सीमा MAX_TIMER_DURATION_MS , तो हम एक स्थानीय मानचित्र में id बचाते हैं ( timerFix ) और फिर runTask कॉल करें जो अवधि को छोटे मानों में विभाजित करता है। runTask एक टाइमआउट सेट करता है (मूल _setTimeout का उपयोग करके) छोटे चंक्स के साथ जो waitingTime बहुत छोटे होने तक लगातार निष्पादित होंगे। जब waitingTime काफी छोटा होता है, तो हम React Native के runAfterInteractions को एक सहज निष्पादन के लिए कहते हैं, और साथ ही, हम अपने स्थानीय मानचित्र से id प्रविष्टि निकालते हैं क्योंकि हम जीते थे इस मामले में _setTimeout फिर से कॉल न करें। ध्यान दें कि afterTime लंबी अवधि के साथ बुलाए जाने से रोकने के लिए _setTimeout में खिलाया जाता है।

अन्यथा, हमारे संशोधित global.setTimeout फ़ंक्शन में, यदि अवधि समय सीमा MAX_TIMER_DURATION_MS से छोटी है, तो हम सीधे वैश्विक सेटटाइमआउट ( _setTimeout में सहेजे गए) कहते हैं।

वैश्विक clearTimeout को स्थानीय मानचित्र से id हटाकर एक सफाई प्रक्रिया करने के लिए भी लपेटा जाता है।

आशा है कि इससे सहायता मिलेगी!

आपको बहुत - बहुत धन्यवाद! एक जादू की तरह काम किया।

नमस्ते, कोड (यहाँ से: firebase / firebase-js-sdk # 97 (टिप्पणी) ) केवल setTimeout (वैश्विक) फ़ंक्शन को लपेटता है ताकि इसे लंबे समय तक उपयोग करने से रोका जा सके।

हमारे संशोधित global.setTimeout फ़ंक्शन में, यदि अवधि समय सीमा MAX_TIMER_DURATION_MS , तो हम एक स्थानीय मानचित्र में id बचाते हैं ( timerFix ) और फिर runTask कॉल करें जो अवधि को छोटे मानों में विभाजित करता है। runTask एक टाइमआउट सेट करता है (मूल _setTimeout का उपयोग करके) छोटे चंक्स के साथ जो waitingTime बहुत छोटे होने तक लगातार निष्पादित होंगे। जब waitingTime काफी छोटा होता है, तो हम React Native के runAfterInteractions को एक सहज निष्पादन के लिए कहते हैं, और साथ ही, हम अपने स्थानीय मानचित्र से id प्रविष्टि निकालते हैं क्योंकि हम जीते थे इस मामले में _setTimeout फिर से कॉल न करें। ध्यान दें कि afterTime लंबी अवधि के साथ बुलाए जाने से रोकने के लिए _setTimeout में खिलाया जाता है।

अन्यथा, हमारे संशोधित global.setTimeout फ़ंक्शन में, यदि अवधि समय सीमा MAX_TIMER_DURATION_MS से छोटी है, तो हम सीधे वैश्विक सेटटाइमआउट ( _setTimeout में सहेजे गए) कहते हैं।

वैश्विक clearTimeout को स्थानीय मानचित्र से id हटाकर एक सफाई प्रक्रिया करने के लिए भी लपेटा जाता है।

आशा है कि इससे सहायता मिलेगी!

क्या यह वास्तव में मुद्दे को संबोधित करता है या यह सिर्फ चेतावनी को हटा देता है?

नमस्ते, कोड (यहाँ से: firebase / firebase-js-sdk # 97 (टिप्पणी) ) केवल setTimeout (वैश्विक) फ़ंक्शन को लपेटता है ताकि इसे लंबे समय तक उपयोग करने से रोका जा सके।

हमारे संशोधित global.setTimeout फ़ंक्शन में, यदि अवधि समय सीमा MAX_TIMER_DURATION_MS , तो हम एक स्थानीय मानचित्र में id बचाते हैं ( timerFix ) और फिर runTask कॉल करें जो अवधि को छोटे मानों में विभाजित करता है। runTask एक टाइमआउट सेट करता है (मूल _setTimeout का उपयोग करके) छोटे चंक्स के साथ जो waitingTime बहुत छोटे होने तक लगातार निष्पादित होंगे। जब waitingTime काफी छोटा होता है, तो हम React Native के runAfterInteractions को एक सहज निष्पादन के लिए कहते हैं, और साथ ही, हम अपने स्थानीय मानचित्र से id प्रविष्टि निकालते हैं क्योंकि हम जीते थे इस मामले में _setTimeout फिर से कॉल न करें। ध्यान दें कि afterTime लंबी अवधि के साथ बुलाए जाने से रोकने के लिए _setTimeout में खिलाया जाता है।

अन्यथा, हमारे संशोधित global.setTimeout फ़ंक्शन में, यदि अवधि समय सीमा MAX_TIMER_DURATION_MS से छोटी है, तो हम सीधे वैश्विक सेटटाइमआउट ( _setTimeout में सहेजे गए) कहते हैं।

वैश्विक clearTimeout को स्थानीय मानचित्र से id हटाकर एक सफाई प्रक्रिया करने के लिए भी लपेटा जाता है।

आशा है कि इससे सहायता मिलेगी!

आपका बहुत बहुत धन्यवाद! यह एप्लिकेशन के समग्र प्रदर्शन को सही नहीं करेगा?

नमस्ते, कोड (यहाँ से: firebase / firebase-js-sdk # 97 (टिप्पणी) ) केवल setTimeout (वैश्विक) फ़ंक्शन को लपेटता है ताकि इसे लंबे समय तक उपयोग करने से रोका जा सके।
हमारे संशोधित global.setTimeout फ़ंक्शन में, यदि अवधि समय सीमा MAX_TIMER_DURATION_MS , तो हम एक स्थानीय मानचित्र में id बचाते हैं ( timerFix ) और फिर runTask कॉल करें जो अवधि को छोटे मानों में विभाजित करता है। runTask एक टाइमआउट सेट करता है (मूल _setTimeout का उपयोग करके) छोटे चंक्स के साथ जो waitingTime बहुत छोटे होने तक लगातार निष्पादित होंगे। जब waitingTime काफी छोटा होता है, तो हम React Native के runAfterInteractions को एक सहज निष्पादन के लिए कहते हैं, और साथ ही, हम अपने स्थानीय मानचित्र से id प्रविष्टि निकालते हैं क्योंकि हम जीते थे इस मामले में _setTimeout फिर से कॉल न करें। ध्यान दें कि afterTime लंबी अवधि के साथ बुलाए जाने से रोकने के लिए _setTimeout में खिलाया जाता है।
अन्यथा, हमारे संशोधित global.setTimeout फ़ंक्शन में, यदि अवधि समय सीमा MAX_TIMER_DURATION_MS से छोटी है, तो हम सीधे वैश्विक सेटटाइमआउट ( _setTimeout में सहेजे गए) कहते हैं।
वैश्विक clearTimeout को स्थानीय मानचित्र से id हटाकर एक सफाई प्रक्रिया करने के लिए भी लपेटा जाता है।
आशा है कि इससे सहायता मिलेगी!

क्या यह वास्तव में मुद्दे को संबोधित करता है या यह सिर्फ चेतावनी को हटा देता है?

नहीं यह मुद्दे को संबोधित नहीं करता है। यह सिर्फ एक अच्छा काम है।

नमस्ते, कोड (यहाँ से: firebase / firebase-js-sdk # 97 (टिप्पणी) ) केवल setTimeout (वैश्विक) फ़ंक्शन को लपेटता है ताकि इसे लंबे समय तक उपयोग करने से रोका जा सके।
हमारे संशोधित global.setTimeout फ़ंक्शन में, यदि अवधि समय सीमा MAX_TIMER_DURATION_MS , तो हम एक स्थानीय मानचित्र में id बचाते हैं ( timerFix ) और फिर runTask कॉल करें जो अवधि को छोटे मानों में विभाजित करता है। runTask एक टाइमआउट सेट करता है (मूल _setTimeout का उपयोग करके) छोटे चंक्स के साथ जो waitingTime बहुत छोटे होने तक लगातार निष्पादित होंगे। जब waitingTime काफी छोटा होता है, तो हम React Native के runAfterInteractions को एक सहज निष्पादन के लिए कहते हैं, और साथ ही, हम अपने स्थानीय मानचित्र से id प्रविष्टि निकालते हैं क्योंकि हम जीते थे इस मामले में _setTimeout फिर से कॉल न करें। ध्यान दें कि afterTime लंबी अवधि के साथ बुलाए जाने से रोकने के लिए _setTimeout में खिलाया जाता है।
अन्यथा, हमारे संशोधित global.setTimeout फ़ंक्शन में, यदि अवधि समय सीमा MAX_TIMER_DURATION_MS से छोटी है, तो हम सीधे वैश्विक सेटटाइमआउट ( _setTimeout में सहेजे गए) कहते हैं।
वैश्विक clearTimeout को स्थानीय मानचित्र से id हटाकर एक सफाई प्रक्रिया करने के लिए भी लपेटा जाता है।
आशा है कि इससे सहायता मिलेगी!

आपका बहुत बहुत धन्यवाद! यह एप्लिकेशन के समग्र प्रदर्शन को सही नहीं करेगा?

नहीं, यह प्रदर्शन को प्रभावित नहीं करता है।

पर एक त्वरित ध्यान दें

यदि यह आपको परेशान करता है, तो आप बस कंसोल जोड़ें ।ignoredYellowBox = ['टाइमर सेट करना'];

तथा

उसी मुद्दे का सामना करते हुए .. जैसा लगता है, हमें समय के लिए चेतावनी को छिपाना होगा। यहाँ यह करने का सबसे छोटा तरीका है:
ComponentsDidMount () {कंसोल .isableYellowBox = true; ...}

यह एक व्यावहारिक समाधान नहीं है। त्रुटियां अभी भी होती हैं, आपको सिर्फ एक सूचना नहीं मिलती है।

परिणाम? त्रुटि पार्सिंग अभी भी होना चाहिए।

उदाहरण के लिए फायरबेस श्रोताओं का उपयोग करने के मामले में आप बड़ी संख्या में त्रुटियों को छिपाएंगे, लेकिन आपका विकास वातावरण अभी भी उन्हें संभाल रहा होगा।

बिंदु में मामला: मेरी एक्सपो आधारित परियोजना दुर्घटनाग्रस्त हो गई क्योंकि यह प्रत्येक टाइमर त्रुटि को स्रोत करने की कोशिश कर रहा था।

मैं इसे बंद कर रहा हूं क्योंकि मुझे नहीं लगता कि रिएक्ट नेटिव कोर में अलार्ममैन के लिए समर्थन जोड़ देगा। यह तीसरे पक्ष के मॉड्यूल या कस्टम मूल कोड के साथ किया जा सकता है।

@cpmech समाधान अभी तक काम करता है? मैंने इसे RN60.4 पर आज़माया, लेकिन लंबे समय तक टाइमर की चेतावनी मिलना अभी बाकी है।

नमस्ते, मुझे लगता है कि मुझे इसका हल मिला:
सबसे पहले आपको अपनी परियोजना में निम्नलिखित फ़ाइल ढूंढनी होगी: पुस्तकालयों / कोर / टाइमर / JSTimer; js
इसे खोलें और आपको अपनी अवधि बढ़ाने के लिए बस इस कॉन्स्टेंस MAX_TIMER_DURATION_MS को बदलना है, चेतावनी के अंत में लिखा है!

टाइमर बढ़ाएं, लेकिन कितना?

@dulmandakh कोई भी ओपन सोर्स प्रोजेक्ट है जो इस मुद्दे को हल करता है जिसे आप जानते हैं?

@dulmandakh कोई भी ओपन सोर्स प्रोजेक्ट है जो इस मुद्दे को हल करता है जिसे आप जानते हैं?

शायद RNFirebase ? @dulmandakh

जब तक यह समाप्त नहीं हो जाता है तब तक आप टाइमर को एक निश्चित समय के साथ पुनर्निर्धारित कर सकते हैं:

const setLogoutTimer = expirationTime => {

  return dispatch => {
    timer = setTimeout(() => {
        if (expirationTime>60000)
        {
            console.log(`set new exp:${expirationTime-60000}`);
            dispatch(setLogoutTimer(expirationTime-60000));
        }
        else
        {
            console.log('logout');
            dispatch(logout());
        }
    }, 60000); 
  };
};

यह 2 साल हो गया है प्रतिक्रिया-मूल या फ़ायरबेस इस मुद्दे को ठीक से ठीक करेगा। :(

ठीक है, लंबी जांच के कुछ घंटों के बाद, मैं जानना चाहता हूं कि क्या मैंने किसी तरह इस मुद्दे का कारण बना।
मुझे यकीन नहीं है जब यह दिखाई दिया।
जैसे ही मैं फायरस्टार कहता हूं, यह पॉप अप हो जाता है?
मैं अपने ऐप में किसी भी टाइमर का उपयोग नहीं कर रहा हूं

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

ईमानदारी से, मुझे नहीं लगता कि जेएस टाइमर / अंतराल का उपयोग करना लंबे समय के लिए वैसे भी एक अच्छा विचार है, चेतावनी एक कारण के लिए है।

इसके बजाय छोटी टाइमर जोड़ने / हटाने के लिए जीवनचक्र की घटनाओं का उपयोग करें। यदि आपको वास्तविक पृष्ठभूमि निष्पादन की आवश्यकता है, तो अग्रभूमि सेवाओं (Android) और पृष्ठभूमि कार्यों (iOS) के साथ मूल कोड का उपयोग करें।

ईमानदारी से, मुझे नहीं लगता कि जेएस टाइमर / अंतराल का उपयोग करना लंबे समय के लिए वैसे भी एक अच्छा विचार है, चेतावनी एक कारण के लिए है।

जैसा कि ऊपर उल्लेख किया गया है, बहुत से लोग पुस्तकालयों के साथ संघर्ष करते हैं जो लंबे समय तक उपयोग करते हैं। "सिर्फ फायरबेस का उपयोग न करें" कोई समाधान नहीं है।

जाहिर है कि यह अक्सर सामने आने वाला मुद्दा है, इसे संभालने से react-native डेवलपर का अनुभव बेहतर होगा जो लगता है कि यह अंतिम है ...

मैं यह नहीं कहूंगा कि "फायरबस का उपयोग न करें" का जवाब है, अधिक पसंद है, "लंबे समय का उपयोग नहीं करने के लिए फायरबेस को ठीक करें और डब्ल्यू / ई कार्य के लिए उपयुक्त देशी बिल्डिंग ब्लॉकों का उपयोग करें जो वे लंबे समय के लिए उपयोग कर रहे हैं"।

लेकिन आप सही हैं, आरएन के लिए यह किसी भी तरह की लंबी समयावधि का समर्थन करने के लिए आदर्श होगा, लेकिन वहाँ सभी चेतावनी पर विचार करना (जैसे उच्च बैटरी की खपत, अनावश्यक पृष्ठभूमि निष्पादन समय, आदि), यह सिर्फ डेवलपर्स को पैर पर खुद को गोली मार देगा। कुछ भी हो, यह एक अलग टाइमर / अंतराल आदिम होना चाहिए।

कुछ भी हो, यह एक अलग टाइमर / अंतराल आदिम होना चाहिए।

इस मुद्दे के बारे में मेरी समझ इस तरह के एक आदिम lack की कमी है

टाइमर के अंदर टाइमर का उपयोग करें, सभी thats!

@dulmandakh यह मुद्दा क्यों बंद है? समस्या बनी रहती है और चर्चा जारी है?

मैंने इसे App.js में जोड़ा, और इसे ठीक कर दिया (अस्थायी है जब तक कि कोई आधिकारिक फिक्स नहीं है)

const _setTimeout = global.setTimeout;
const _clearTimeout = global.clearTimeout;
const MAX_TIMER_DURATION_MS = 60 * 1000;
if (Platform.OS === "android") {
  // Work around issue `Setting a timer for long time`
  // see: https://github.com/firebase/firebase-js-sdk/issues/97
  const timerFix = {};
  const runTask = (id, fn, ttl, args) => {
    const waitingTime = ttl - Date.now();
    if (waitingTime <= 1) {
      InteractionManager.runAfterInteractions(() => {
        if (!timerFix[id]) {
          return;
        }
        delete timerFix[id];
        fn(...args);
      });
      return;
    }

    const afterTime = Math.min(waitingTime, MAX_TIMER_DURATION_MS);
    timerFix[id] = _setTimeout(() => runTask(id, fn, ttl, args), afterTime);
  };

  global.setTimeout = (fn, time, ...args) => {
    if (MAX_TIMER_DURATION_MS < time) {
      const ttl = Date.now() + time;
      const id = "_lt_" + Object.keys(timerFix).length;
      runTask(id, fn, ttl, args);
      return id;
    }
    return _setTimeout(fn, time, ...args);
  };

  global.clearTimeout = id => {
    if (typeof id === "string" && id.startWith("_lt_")) {
      _clearTimeout(timerFix[id]);
      delete timerFix[id];
      return;
    }
    _clearTimeout(id);
  };
}

यह वर्कअराउंड है, न कि फिक्स।

मैंने इसे App.js में जोड़ा, और इसे ठीक कर दिया (अस्थायी है जब तक कि कोई आधिकारिक फिक्स नहीं है)

...
    if (typeof id === "string" && id.startWith("_lt_")) {
...

यदि आप उस कोड का उपयोग करने जा रहे हैं, तो 'startWith' 'startWith' होना चाहिए।

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

import { YellowBox } from 'react-native';
YellowBox.ignoreWarnings(['Setting a timer']);

यह मेरे लिए स्पष्ट नहीं है कि अंतर्निहित मुद्दा कुछ ऐसा है जिसे RN को ठीक करने की आवश्यकता है, Amplify को ठीक करने की आवश्यकता है, या ऐसा कुछ है जिसे मुझे पैच करने की आवश्यकता है। जाहिर है मुझे प्रदर्शन के मुद्दे नहीं चाहिए।

यदि यह आपको परेशान करता है तो आप console.ignoredYellowBox = ['Setting a timer']; जोड़ते हैं

मुझे इसे कहां जोड़ना चाहिए मैंने स्क्रीन फ़ाइल और एक्शन फ़ाइल में कोशिश की, अभी भी काम नहीं कर रहा है

बस इसे अपने App.js फ़ाइल में कहीं रखें। मैंने इसे अपने निर्माता में उदाहरण के लिए रखा।
नहीं पता कि यह सबसे अच्छी जगह है, इसलिए अगर किसी को कुछ भी बेहतर पता है, तो मैं इसे सुनना चाहूंगा!

मुझे लगता है कि जो कोई भी Firebase का उपयोग कर रहा है, वह इस समस्या को हल करने के बाद एप्लिकेशन की दृढ़ता को कॉन्फ़िगर कर सकता है (साइन इन / साइनअप)

* एक नया उपयोगकर्ता बनाने के बाद, वह स्वतः साइन इन हो जाएगा

https://firebase.google.com/docs/auth/web/auth-state-persistence

इसलिए ... उपयोगकर्ता के बाद, एक समय चर बनाया जाता है।

फायरबेस के लिए डिफ़ॉल्ट एक local । "Firebase.auth.Auth.Persistence.LOCAL"

आप का उपयोग कर बदल सकते हैं:
firebase.auth.Auth.Persistence.SESSION
firebase.auth.Auth.Persistence.NONE

या एक स्थानीय स्तर का उपयोग कर ...

जब तक वे इसे एक निश्चित तरीके से हल नहीं करते ...

"प्रतिक्रिया-मूल" से {यलोबॉक्स} आयात करें;
"_आश" से आयात _;
YellowBox.ignoreWarnings (["टाइमर सेट करना"]);
const _console = _.clone (कंसोल);
सांत्वना.द्वारा = (संदेश) => {
अगर (message.indexOf ("टाइमर सेट करना") <= -1) {
_console.warn (संदेश);
}
};

एक बार हल करने के बाद, जंक कोड हटा दिया जाता है और वॉइला!

इसे RxJS के साथ हल किया जा सकता है।

मूलतः आपके 5200 टाइमर को 5 * 1000 + 200 टाइमर में विभाजित करता है।

import { of, range } from 'rxjs';
import {
  concatMap,
  delay,
  filter,
  mapTo,
  switchMap,
  tap,
} from 'rxjs/operators';

// ~ setTimeout(..., 5200);

const source = of(5200).pipe(
  switchMap(duration => {
    const times = Math.floor(duration / 1000); // = 5
    const remainder = duration % 1000; // = 200

    return range(1, times).pipe(
      concatMap(i => of(i).pipe(delay(1000))),
      tap(console.log),
      filter(i => i === times),
      delay(remainder),
      tap(console.log),
      mapTo('Done !'),
    );
  }),
);

source.subscribe(console.log);

1 // After 1s
2 // After 2s
3 // After 3s
4 // After 4s
5 // After 5s
5 // After 5s + 200 ms
'Done !'

मुझे लगता है कि जो कोई भी Firebase का उपयोग कर रहा है, वह इस समस्या को हल करने के बाद एप्लिकेशन की दृढ़ता को कॉन्फ़िगर कर सकता है (साइन इन / साइनअप)

* एक नया उपयोगकर्ता बनाने के बाद, वह स्वतः साइन इन हो जाएगा

https://firebase.google.com/docs/auth/web/auth-state-persistence

इसलिए ... उपयोगकर्ता के बाद, एक समय चर बनाया जाता है।

फायरबेस के लिए डिफ़ॉल्ट एक local । "Firebase.auth.Auth.Persistence.LOCAL"

आप का उपयोग कर बदल सकते हैं:
firebase.auth.Auth.Persistence.SESSION
firebase.auth.Auth.Persistence.NONE

या एक स्थानीय स्तर का उपयोग कर ...

महान! हालांकि फायरस्टार के लिए कैसे?

मुझे लगता है कि जो कोई भी Firebase का उपयोग कर रहा है, वह इस समस्या को हल करने के बाद एप्लिकेशन की दृढ़ता को कॉन्फ़िगर कर सकता है (साइन इन / साइनअप)
* एक नया उपयोगकर्ता बनाने के बाद, वह स्वतः साइन इन हो जाएगा
https://firebase.google.com/docs/auth/web/auth-state-persistence
इसलिए ... उपयोगकर्ता के बाद, एक समय चर बनाया जाता है।
फायरबेस के लिए डिफ़ॉल्ट एक local । "Firebase.auth.Auth.Persistence.LOCAL"
आप का उपयोग कर बदल सकते हैं:
firebase.auth.Auth.Persistence.SESSION
firebase.auth.Auth.Persistence.NONE
या एक स्थानीय स्तर का उपयोग कर ...

महान! हालांकि फायरस्टार के लिए कैसे?

यदि आप पुराने फायरबेस एसडीके का उपयोग कर रहे हैं तो फायरस्टार व्यवस्थापक एसडीके को माइग्रेट करें।

अधिकांश मुद्दों को हल किया जाएगा

https://firebase.google.com/docs/reference/admin

फिर भी कोई भी इस मुद्दे को हल करने में सक्षम नहीं है। आप डेवलपर्स पर # शर्म करो; पी

फिर भी कोई भी इस मुद्दे को हल करने में सक्षम नहीं है। आप डेवलपर्स पर # शर्म करो; पी

कभी भी ओपन सोर्स योगदानकर्ताओं को शर्मिंदा न करें। यह शर्म की बात है यह तय नहीं किया गया है लेकिन स्रोत खुला है, अगर आप जानते हैं कि इसे कैसे हल किया जाए तो मुझे यकीन है कि वे एक पुल-अनुरोध की सराहना करेंगे।

कहा कि पृथ्वी पर यह मुद्दा क्यों बंद है ।

क्योंकि यह आपत्तिजनक पुस्तकालयों में तय किया जाना चाहिए। और जिस तरह से इसे लागू किया गया है उससे आपत्तिजनक पुस्तकालयों को कोई समस्या नहीं दिखती है।

तो कोई भी इसे ठीक नहीं करेगा क्योंकि दोनों पक्षों को नहीं लगता कि यह टूट गया है।

वे इस के लिए एक _little bit_ को शर्मिंदा कर सकते हैं

दोस्तों, मुझे लगता है कि यह सरल कारण के लिए "हल" नहीं किया गया है कि यह लंबी टाइमर का उपयोग करने के लिए एक बहुत बुरा विचार है।

यदि आप भविष्य में पृष्ठभूमि / घटनाओं में टाइमर चलाना चाहते हैं, तो आपको ऐसा करने के लिए एक देशी पुस्तकालय की आवश्यकता होगी। पृष्ठभूमि निष्पादन की बाधाओं के कारण दोनों प्लेटफार्मों पर यह विशेष रूप से कठिन है।

@Eightyfive की टिप्पणी के आधार पर हमने rxjs6 delay , timeout & interval कार्यों के लिए प्रतिस्थापन में एक गिरावट दर्ज की।

अभी भी एक सवाल बना हुआ है, क्या कोई समझा सकता है कि "टाइमर मॉड्यूल" छोटे अंतराल का उपयोग करते समय बंद रहता है? मूल रूप से सिर्फ टाइमर के रुकने का कारण बनता है जब ऐप अग्रभूमि में नहीं होता है। या यह सिर्फ समस्या को छिपाता है?

import { switchMap, concatMap, delay as nativeDelay, mapTo, filter, switchMapTo, repeat } from 'rxjs/operators'
import { range, of, race, throwError, TimeoutError } from 'rxjs'

const TIMER_INTERVAL = 1000
const reactNativeTimer = (duration) => {
  const times = Math.floor(duration / TIMER_INTERVAL)
  const remainder = duration % TIMER_INTERVAL
  if (times < 1) {
    return of(true).pipe(nativeDelay(remainder))
  }
  return range(1, times).pipe(
    concatMap(i => of(i).pipe(nativeDelay(TIMER_INTERVAL))),
    filter(i => i === times),
    nativeDelay(remainder)
  )
}

/**
 * React Native compatible version of delay pipe
 * <strong i="11">@param</strong> {number} duration in ms
 */
export const delay = (duration) => {
  return (source) => {
    return source.pipe(
      switchMap(next =>
        reactNativeTimer(duration).pipe(mapTo(next))
      )
    )
  }
}

/**
 * React Native compatible version of timeout pipe
 * <strong i="12">@param</strong> {number} duration in ms
 */
export const timeout = (duration) => {
  return (source) => {
    const timeoutTimer = reactNativeTimer(duration).pipe(
      switchMapTo(throwError(new TimeoutError()))
    )
    return race(source, timeoutTimer)
  }
}

/**
 * React Native compatible version of interval
 * <strong i="13">@param</strong> {number} duration in ms
 */
export const interval = (duration) => {
  return reactNativeTimer(duration).pipe(
    repeat()
  )
}

इसके बारे में मजेदार बात यह है कि इस थ्रेड में हर कोई इस चेतावनी को अनदेखा करने के लिए वर्कअराउंड पर चर्चा कर रहा है।
जब मुझे चेतावनी से इस "मुद्दे" पर पुनर्निर्देशित किया गया था, तो मुझे "कैसे?" समझाते हुए, उचित दस्तावेज मिलने की उम्मीद थी। इसे संभालना और "क्यों?" के बारे में कुछ और तर्क देना।

फ्रंट-एंड #millennials

यह #millenial यह बताना चाहता है कि:

• इस त्रुटि के लिए दस्तावेज़ीकरण की आवश्यकता नहीं है, यह स्व व्याख्यात्मक है: आपने एक लंबा टाइमर सेट किया है।
• यह धागा ऐसे लोगों के लिए चेतावनी से भरा हुआ है, जिनके पास पुस्तकालय नहीं है (जैसे फायरबेस)
• जैसा कि इस थ्रेड में (उत्पादक) चर्चा इंगित करती है, यह react-native भीतर ठीक करने के लिए एक अधिक जटिल समस्या है

मैंने कहा कि मैं फिर से बताऊंगा कि यह मुद्दा बंद नहीं होना चाहिए, यह known-issue और Help Wanted चिह्नित है।

सहस्राब्दियों से मिलेनियल उत्तर :)

इस त्रुटि के लिए दस्तावेज़ीकरण की आवश्यकता नहीं है, यह स्व व्याख्यात्मक है: आपने एक लंबा टाइमर सेट किया है।

• इसकी कोई त्रुटि नहीं, इसकी चेतावनी (अंतर के बारे में मुझसे न पूछें, अन्यथा हमें गहरी दार्शनिक बातचीत शुरू करनी होगी :)
• इसके पहले से ही इस टिकट के संदर्भ के कारण प्रलेखित होने का दिखावा किया जाता है, जहाँ मुझे कार्यकारी सारांश के बजाय टन टिप्पणी पढ़ने की जरूरत है (जैसा कि आप पहले से ही सुझाए गए मुद्दे की तरह ही देखें):
  
• मैं इसे 'आत्म व्याख्यात्मक' नहीं कहूंगा। पर्याप्त संदर्भ उपलब्ध नहीं कराया गया। वस्तुतः, एक विवरण में दो वाक्य हैं।

मैंने कहा कि मैं फिर से बताऊंगा कि यह मुद्दा बंद नहीं होना चाहिए, यह ज्ञात मुद्दा है और हेल्प वांटेड है।

पूरी तरह से सहमत। यह चेतावनी में URL संदर्भ से आने वाले कई लोगों का समय बचाएगा।

फायरबेस / फायरस्टार उपयोगकर्ताओं के लिए: मैं बस फायरस्टार कॉल के लिए सीधे REST समापन बिंदुओं का उपयोग करने के लिए वापस लौट आया। चूँकि मुझे केवल ऑउटफिट और फायरस्टार की जरूरत थी, जिससे मेरी समस्याओं का हल आसानी से हो गया। यहाँ स्निपेट:

https://stackoverflow.com/a/62446792

मैंने इसे ऐप के अंदर किया () निम्नानुसार है:

आयात 'येलोबॉक्स' 'प्रतिक्रिया-मूल' से;
निर्यात डिफ़ॉल्ट फ़ंक्शन ऐप () {
YellowBox.ignoreWarnings (['टाइमर सेट करना']);
...
...
..
}

याद रखें

मैंने क्या किया और यह मेरे साथ काम कर रहा है लेकिन फिर भी मैं यह नहीं जानता कि यह अच्छा अभ्यास है या नहीं

फाइल करने के लिए नेविगेट किया गया

node_modulesreact देशी \ पुस्तकालय \ कोर \ TimersJSTimers.js

वहाँ एक कार्य const MAX_TIMER_DURATION_MS = 60 * 1000 और मैंने समय बढ़ाकर 60 * 100000 कर दिया है और यह दिखावटी है

सुनो,
यह समस्या लगभग 3 साल पुरानी है और हम अभी भी यह चेतावनी दे रहे हैं;)
जैसा कि @RWOverdijk ने कहा कि चेतावनी की अनदेखी करना समाधान नहीं है।
वहाँ पहले से ही एक समाधान है कि मैं याद किया?

धन्यवाद <3

अरे सब, हम इस मुद्दे को बंद करने का फैसला कर रहे हैं। मुझे पता है कि यह समस्या आप में से कई के लिए निराशाजनक है और मैं यह समझने में मदद करने के लिए समय लेना चाहता हूं कि हम यह निर्णय क्यों ले रहे हैं।

रिएक्ट नेटिव में एंड्रॉइड पर टाइमर कैसे काम करते हैं

रिएक्ट नेटिव में setTimeout जैसे JS टाइमर का कस्टम कार्यान्वयन है। एंड्रॉइड पर, जिस तरह से यह काम करता है वह यह है कि जेएस टाइमर को देशी तरफ ट्रैक किया जाता है, और इन टाइमर को ट्रिगर करने के लिए देशी पक्ष तय करता है। यह प्रतिक्रियाशील मूल निवासी के बारे में होशियार है जब टाइमर ट्रिगर कर रहे हैं, और विशेष रूप से कैसे वे अनुप्रयोग जीवन चक्र और प्रतिपादन से संबंधित हैं।

यदि मैं एक लंबे अंतराल के साथ टाइमर सेट करूँ तो क्या होगा?

यहाँ मेरी समझ है, कोड को पढ़ने और इसे थोड़ा परीक्षण करने से:

1. यदि आप एक लंबा टाइमर सेट करते हैं, और ऐप को टाइमर सक्रिय होने के दौरान खुला रखा जाता है, तो टाइमर को अभी भी काम करना चाहिए।
2. यदि आप एक लंबा टाइमर सेट करते हैं, और टाइमर समाप्त होने से पहले फोन को बैकग्राउंड किया जाता है, तो जब तक आप ऐप को नहीं खोलते तब तक टाइमर सक्रिय नहीं होगा।
3. हेडलेस जेएस कार्यों के लिए एक अपवाद है, जो ऐप में पृष्ठभूमि में होने पर भी टाइमर काम कर सकता है।

हमें लंबे अंतराल के साथ टाइमर क्यों नहीं बुलाने चाहिए?

मुझे लगता है कि यह मुख्य रूप से एक शुद्धता मुद्दा है, और प्रदर्शन के बारे में कम है। मुद्दा यह है कि यदि उपयोगकर्ता आपके ऐप को बैकग्राउंड करता है तो आप लंबे समय तक भरोसा नहीं कर सकते।

अगर आपको इस बात से कोई आपत्ति नहीं है कि बाद में जब ऐप फिर से ग्राउंडेड हो जाता है तो आपका टाइमर सक्रिय हो जाता है, तो मुझे लगता है कि येलोबॉक्स चेतावनी को नजरअंदाज करना एक अच्छा विचार है।

दूसरी ओर, यदि आपका टाइमर एक सत्र के जीवनकाल के लिए बुलाए जाने की उम्मीद करता है, और फिर से अग्रभूमि पर ट्रिगर नहीं किया जाना चाहिए, तो आपको यह सुनिश्चित करने के लिए कुछ करने की आवश्यकता होगी कि टाइमर को अग्रभूमि पर अनदेखा किया गया है।

मैं सॉकेट.आई.ओ और फायरबेस जैसी थर्ड-पार्टी लाइब्रेरी का उपयोग कैसे करूं जो लंबी टाइमिंग सेट करती हैं?

मुझे इन तृतीय-पक्ष पुस्तकालयों का विवरण नहीं पता है। यह अंततः ऊपर दिए गए प्रश्न पर आता है। यदि इन तृतीय-पक्ष पुस्तकालयों में अग्रभूमि पर हल किए जा रहे समय से निपटने के मुद्दे होंगे, तो आपको इसे ठीक करने का तरीका जानने की आवश्यकता होगी। उदाहरण के लिए, Firebase के लिए ऐसा करने के कुछ तरीके ऊपर दिए गए कुछ टिप्पणियां हैं। अंततः, हालांकि, आपको एक पुस्तकालय पर भरोसा करके बेहतर सेवा दी जा सकती है जो विशेष रूप से प्रतिक्रियाशील मूल निवासी को ध्यान में रखते हुए विकसित की गई है।

दूसरी ओर, यदि तीसरे पक्ष के पुस्तकालय में अग्रभूमि पर हल किए जा रहे समय के साथ कोई समस्या नहीं है, तो आप त्रुटि को अनदेखा कर सकते हैं।

जैसा कि शुरू में सुझाव दिया गया कि setTimeout AlarmManager क्यों नहीं चल सकता?

AlarmManager पृष्ठभूमि में होने पर ऐप को जगा देगा, और हमें नहीं लगता कि setTimeout जैसे टाइमर को ऐप को जगाना चाहिए। इनमें से ज्यादातर लंबी समयावधि टाइमआउट जैसी चीजों के लिए निर्धारित की जाती हैं, और वे केवल प्रासंगिक हैं जबकि ऐप खुला है। बैकग्राउंड में एक ऐप को जगाना महंगा है और इसे तभी किया जाना चाहिए जब डेवलपर के पास स्पष्ट रूप से यह इरादा हो।

इसी समय, कई लोगों को शायद कुछ इस तरह की आवश्यकता होती है। हम इसके लिए एक एपीआई विकसित कर सकते हैं जो setTimeout माध्यम से नहीं जाता है। लेकिन अभी लीन कोर प्रयास के कारण हम वास्तव में रिएक्ट नेटिव के लिए एपीआई सतह बढ़ाने से बचने की कोशिश कर रहे हैं। हम सोचते हैं कि यह react-native-background-timer जैसी किसी तृतीय-पक्ष लाइब्रेरी द्वारा संभाला जाने वाला कार्य है।

आप चेतावनी को पूरी तरह से क्यों नहीं हटाते?

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