অ্যান্ড্রয়েড। টুকরোগুলি getActivity () কখনও কখনও শূন্য প্রদান করে

Question

বিকাশকারী কনসোল ত্রুটির প্রতিবেদনে মাঝে মাঝে আমি এনপিই ইস্যু সহ প্রতিবেদনগুলি দেখতে পাই। আমার কোডটিতে কী ভুল তা আমি বুঝতে পারি না। এমুলেটরটিতে এবং আমার ডিভাইসের অ্যাপ্লিকেশন ফোর্সক্লোসগুলি ছাড়াই ভাল কাজ করে, তবে কিছু ব্যবহারকারী যখন অ্যাক্টিভিটি () পদ্ধতিটি কল করা হয় তখন খণ্ড শ্রেণিতে নুলপয়েন্টারএক্সসেপশন পান।

কার্যকলাপ

pulic class MyActivity extends FragmentActivity{

    private ViewPager pager; 
    private TitlePageIndicator indicator;
    private TabsAdapter adapter;

    @Override
    public void onCreate(Bundle savedInstanceState) {
        pager = (ViewPager) findViewById(R.id.pager);
        indicator = (TitlePageIndicator) findViewById(R.id.indicator);
        adapter = new TabsAdapter(getSupportFragmentManager(), false);

        adapter.addFragment(new FirstFragment());
        adapter.addFragment(new SecondFragment());
        indicator.notifyDataSetChanged();
        adapter.notifyDataSetChanged();

        // push first task
        FirstTask firstTask = new FirstTask(MyActivity.this);
        // set first fragment as listener
        firstTask.setTaskListener((TaskListener) adapter.getItem(0));
        firstTask.execute();
    }

    indicator.setOnPageChangeListener(new ViewPager.OnPageChangeListener()  {
        @Override
        public void onPageSelected(int position) {
            Fragment currentFragment = adapter.getItem(position);
            ((Taskable) currentFragment).executeTask();
        }

        @Override
        public void onPageScrolled(int i, float v, int i1) {}

        @Override
        public void onPageScrollStateChanged(int i) {}
    });
}

অ্যাসিঙ্কটাস্ক ক্লাস

public class FirstTask extends AsyncTask{

    private TaskListener taskListener;

    ...

    @Override
    protected void onPostExecute(T result) {
        ... 
        taskListener.onTaskComplete(result);
    }   
}

টুকরা ক্লাস

public class FirstFragment extends Fragment immplements Taskable, TaskListener{

    public FirstFragment() {
    }

    @Override
    public View onCreateView(LayoutInflater inflater, ViewGroup container, Bundle savedInstanceState) {
        return inflater.inflate(R.layout.first_view, container, false);
    }

    @Override
    public void executeTask() {
        FirstTask firstTask = new FirstTask(MyActivity.this);
        firstTask.setTaskListener(this);
        firstTask.execute();
    }

    @Override
    public void onTaskComplete(T result) {
        // NPE is here 
        Resources res = getActivity().getResources();
        ...
    }
}

অ্যাপ্লিকেশনগুলি পটভূমি থেকে পুনরায় শুরু করার সময় এই ত্রুটিটি ঘটতে পারে। এই ক্ষেত্রে আমার এই পরিস্থিতিটি কীভাবে সঠিকভাবে পরিচালনা করা উচিত?

Comments

আমি একটি সমস্যা খুঁজে বের করেছি, তবে সমাধান নয়। আমি জানি না কেন খণ্ডগুলি পূর্বের ক্রিয়াকলাপটি পুনরায় শুরু করে। এবং এটি কেবল তখন ঘটে যখন আমার অ্যাপ্লিকেশনগুলি সম্প্রতি অ্যাপ্লিকেশনগুলির তালিকার শেষ অবস্থানে রয়েছে, মনে হয় সিস্টেমটি আমার অ্যাপ্লিকেশনটিকে ধ্বংস করে।

— জর্জি গোবোজভ

আমি যখন আমার অ্যাপ্লিকেশনটিকে ব্যাকগ্রাউন্ড টুকরো টুকরো টুকরোটি থেকে পুনরায় শুরু করি তখন অনক্রিয়েট / অনরেসুম পদ্ধতিটির ক্রিয়াকলাপের আগে কল করা একটি অনারিউজ তৈরি করুন। মনে হচ্ছে কিছু বিচ্ছিন্ন খণ্ড এখনও জীবিত এবং আবার চেষ্টা করার চেষ্টা করছে।

— জর্জি গোবোজভ

এই স্ট্রিংয়ে প্রথম টাস্ক.সেটটাস্কলিস্টনার ((টাস্কলাইস্টেনার) অ্যাডাপ্টার.জেট আইটেম (0)); অ্যাডাপ্টার.জেটআইটেম (0) পুরানো টুকরো ফিরে আসে, অ্যাডাপ্টার সঠিকভাবে টুকরো টুকরো মুছে না

— জর্জি গোবোজভ

দারুণ ক্রিয়াকলাপ :) প্রশ্ন জিজ্ঞাসা করা হয়েছে, মন্তব্যগুলি বামে দেওয়া হয়েছে এবং উত্তর দেওয়া হয়েছে - সবই একক ব্যক্তি দ্বারা সম্পন্ন হয়! এই জন্য +1।

— প্রিয়ফফ

কনটেক্সট (getActivity ()) onCreateView () এ সংরক্ষণ করুন কারণ এটি যখন ব্যাকগ্রাউন্ডের ক্ষেত্রে পুনরায় তৈরি করা হয় তখন এটি বলা হয়।

— শে

Answer 1

দেখে মনে হচ্ছে যে আমি আমার সমস্যার সমাধান পেয়েছি। খুব ভাল ব্যাখ্যা এখানে এবং এখানে দেওয়া হয় । এখানে আমার উদাহরণ:

pulic class MyActivity extends FragmentActivity{

private ViewPager pager; 
private TitlePageIndicator indicator;
private TabsAdapter adapter;
private Bundle savedInstanceState;

 @Override
public void onCreate(Bundle savedInstanceState) {

    .... 
    this.savedInstanceState = savedInstanceState;
    pager = (ViewPager) findViewById(R.id.pager);;
    indicator = (TitlePageIndicator) findViewById(R.id.indicator);
    adapter = new TabsAdapter(getSupportFragmentManager(), false);

    if (savedInstanceState == null){    
        adapter.addFragment(new FirstFragment());
        adapter.addFragment(new SecondFragment());
    }else{
        Integer  count  = savedInstanceState.getInt("tabsCount");
        String[] titles = savedInstanceState.getStringArray("titles");
        for (int i = 0; i < count; i++){
            adapter.addFragment(getFragment(i), titles[i]);
        }
    }


    indicator.notifyDataSetChanged();
    adapter.notifyDataSetChanged();

    // push first task
    FirstTask firstTask = new FirstTask(MyActivity.this);
    // set first fragment as listener
    firstTask.setTaskListener((TaskListener) getFragment(0));
    firstTask.execute();

}

private Fragment getFragment(int position){
     return savedInstanceState == null ? adapter.getItem(position) : getSupportFragmentManager().findFragmentByTag(getFragmentTag(position));
}

private String getFragmentTag(int position) {
    return "android:switcher:" + R.id.pager + ":" + position;
}

 @Override
protected void onSaveInstanceState(Bundle outState) {
    super.onSaveInstanceState(outState);
    outState.putInt("tabsCount",      adapter.getCount());
    outState.putStringArray("titles", adapter.getTitles().toArray(new String[0]));
}

 indicator.setOnPageChangeListener(new ViewPager.OnPageChangeListener() {
        @Override
        public void onPageSelected(int position) {
            Fragment currentFragment = adapter.getItem(position);
            ((Taskable) currentFragment).executeTask();
        }

        @Override
        public void onPageScrolled(int i, float v, int i1) {}

        @Override
        public void onPageScrollStateChanged(int i) {}
 });

এই কোডটির মূল ধারণাটি হ'ল, আপনার অ্যাপ্লিকেশনটি স্বাভাবিকভাবে চালানোর সময় আপনি নতুন টুকরোগুলি তৈরি করে অ্যাডাপ্টারে পাস করেন। আপনি যখন নিজের অ্যাপ্লিকেশনটি পুনরায় চালু করছেন খণ্ডের ব্যবস্থাপকটির ইতিমধ্যে এই খণ্ডটির উদাহরণ রয়েছে এবং আপনার এটি খণ্ড পরিচালকের কাছ থেকে নেওয়া এবং এটি অ্যাডাপ্টারে পাস করা দরকার।

হালনাগাদ

এছাড়াও, গতিঅ্যাক্টিভিটি () কল করার আগে সংযুক্তিগুলি পরীক্ষা করার জন্য টুকরা ব্যবহার করার সময় এটি একটি ভাল অনুশীলন। যখন খণ্ডটি ক্রিয়াকলাপ থেকে বিচ্ছিন্ন হয়ে যায় তখন এটি নাল পয়েন্টার ব্যতিক্রম এড়াতে সহায়তা করে। উদাহরণস্বরূপ, কোনও ক্রিয়াকলাপে এমন একটি খণ্ড থাকতে পারে যা একটি অ্যাসিঙ্ক কার্যকে ধাক্কা দেয়। টাস্ক শেষ হয়ে গেলে, অন টাস্ক কমপ্লিট শ্রোতাদের ডাকা হয়।

@Override
public void onTaskComplete(List<Feed> result) {

    progress.setVisibility(View.GONE);
    progress.setIndeterminate(false);
    list.setVisibility(View.VISIBLE);

    if (isAdded()) {

        adapter = new FeedAdapter(getActivity(), R.layout.feed_item, result);
        list.setAdapter(adapter);
        adapter.notifyDataSetChanged();
    }

}

যদি আমরা খণ্ডটি খুলি, কোনও কার্যকে চাপ দিন এবং তারপরে দ্রুত কোনও পূর্ববর্তী ক্রিয়াকলাপে ফিরে আসতে টিপুন, টাস্কটি শেষ হয়ে গেলে, এটি getActivity () পদ্ধতিতে কল করে onPostExecute () এ ক্রিয়াকলাপটি অ্যাক্সেস করার চেষ্টা করবে। যদি কার্যকলাপটি ইতিমধ্যে পৃথক হয়ে থাকে এবং এই চেকটি না থাকে:

if (isAdded()) 

তারপরে অ্যাপ্লিকেশন ক্রাশ হয়ে গেছে।

Comments

এটি যদিও বিরক্তিকর, isAdded()প্রতিটি অ্যাক্সেসের আগে কল করতে হয়েছিল ... কোডটিকে কুৎসিত করে।

— আইএক্সএক্স

মনে হচ্ছে না যেif(isAdded())if(getActivity() != null)

— স্ট্যাকওভারফ্লো হয়েছে এর

Answer 2

ঠিক আছে, আমি জানি যে এই প্রশ্নটি আসলে সমাধান করা হয়েছে তবে আমি এর জন্য আমার সমাধান ভাগ করে নেওয়ার সিদ্ধান্ত নিয়েছি। আমি আমার জন্য বিমূর্ত অভিভাবক শ্রেণি তৈরি করেছি Fragment:

public abstract class ABaseFragment extends Fragment{

    protected IActivityEnabledListener aeListener;

    protected interface IActivityEnabledListener{
        void onActivityEnabled(FragmentActivity activity);
    }

    protected void getAvailableActivity(IActivityEnabledListener listener){
        if (getActivity() == null){
            aeListener = listener;

        } else {
            listener.onActivityEnabled(getActivity());
        }
    }

    @Override
    public void onAttach(Activity activity) {
        super.onAttach(activity);

        if (aeListener != null){
            aeListener.onActivityEnabled((FragmentActivity) activity);
            aeListener = null;
        }
    }

    @Override
    public void onAttach(Context context) {
        super.onAttach(context);

        if (aeListener != null){
            aeListener.onActivityEnabled((FragmentActivity) context);
            aeListener = null;
        }
    }
}

যেমন আপনি দেখতে পাচ্ছেন, আমি শ্রোতার সাথে যুক্ত করেছি, যখনই আমাকে Fragments Activityস্ট্যান্ডার্ডের পরিবর্তে দরকার হয় getActivity(), আমাকে ফোন করতে হবে

 getAvailableActivity(new IActivityEnabledListener() {
        @Override
        public void onActivityEnabled(FragmentActivity activity) {
            // Do manipulations with your activity
        }
    });

Comments

দুর্দান্ত উত্তর! এটি সঠিক সমস্যা হিসাবে চিহ্নিত করা উচিত কারণ এটি আসল সমস্যাটি সমাধান করে: আমার ক্ষেত্রে এটি getActivity () নাল নয় তা যাচাই করার পক্ষে যথেষ্ট নয় কারণ আমার কাজটি অবশ্যই যাই হোক না কেন সম্পূর্ণ করতে হবে। আমি এটি ব্যবহার করছি এবং এটি নিখুঁতভাবে কাজ করে।

— হাডাস কামিনস্কি

Answer 3

এ থেকে পরিত্রাণের জন্য সর্বোত্তম হ'ল যখন onAttachবলা হয় তখন কার্যকলাপের রেফারেন্স রাখা এবং যেখানে প্রয়োজন সেখানে ক্রিয়াকলাপের রেফারেন্স ব্যবহার করা যেমন, যেমন

@Override
public void onAttach(Context context) {
    super.onAttach(context);
    mContext = context;
}

@Override
public void onDetach() {
    super.onDetach();
    mContext = null;
}

সম্পাদিত, যেহেতু onAttach(Activity)অবহেলিত এবং এখন onAttach(Context)ব্যবহৃত হচ্ছে

Comments

খণ্ডগুলি সর্বদা তার পিতামাতার ক্রিয়াকলাপের রেফারেন্স রাখে এবং আপনাকে getActivity () পদ্ধতিতে উপলব্ধ করে তোলে, আমরা এখানে একই রেফারেন্স রাখছি।

— পবন মহেশ্বরী

ক্রিয়াকলাপের সাথে ইভেন্টগুলি ভাগ করার জন্য আপনার খণ্ডের প্রয়োজন হলে গুগল আসলে এটি প্রস্তাব করে। বিকাশকারী.অ্যান্ড্রয়েড.

— com

আপনি onDetach পদ্ধতি যুক্ত করতে চাইতে পারেন, যা ক্রিয়াকলাপের রেফারেন্সকে বাতিল করে দেয়

— মধ্যরাত

হ্যাঁ mActivity শুরু করুন = ক্রিয়াকলাপের উল্লেখটি বাতিল করার জন্য onDetach পদ্ধতিটি বাতিল করুন।

— পবন মহেশ্বরী

কখনই না। আপনি আপনার সম্পূর্ণ ক্রিয়াকলাপ ফাঁস করছেন (এবং এটির সাথে পুরো লেআউট ট্রি, অঙ্কনযোগ্য এবং এর মতো)। যদি getActivity()শূন্য ফিরে আসে, কারণ আপনি আর কোনও ক্রিয়াকলাপে নেই। এটি একটি নোংরা কাজ।

— njzk2

Answer 4

অবিচ্ছিন্ন ক্রিয়াকলাপে অন স্টার্ট পর্যন্ত getActivity () প্রয়োজন এমন খণ্ডের মধ্যে এমন পদ্ধতিগুলিকে কল করবেন না।

private MyFragment myFragment;


public void onCreate(Bundle savedInstanceState)
{
    super.onCreate(savedInstanceState);

    FragmentTransaction ft = getSupportFragmentManager().beginTransaction();
    myFragment = new MyFragment();

    ft.add(android.R.id.content, youtubeListFragment).commit();

    //Other init calls
    //...
}


@Override
public void onStart()
{
    super.onStart();

    //Call your Fragment functions that uses getActivity()
    myFragment.onPageSelected();
}

Comments

প্রকৃতপক্ষে, আমারও একই সমস্যা ছিল কারণ আমি খণ্ড নির্মাণকারীতে কাজ শুরু করছিলাম। অনেক ধন্যবাদ.

— সুপ্রিম ডলফিন

Answer 5

আমি এই ধরণের সমস্যার সাথে লড়াই করছি কিছুক্ষণের জন্য করছি এবং আমি মনে করি আমি একটি নির্ভরযোগ্য সমাধান নিয়ে এসেছি।

এটা তোলে নিশ্চিত জানি যে প্রশংসনীয় কঠিন this.getActivity()আসতে যাচ্ছে না nullএকটি জন্য Fragment, বিশেষ করে যদি আপনি কোন প্রত্যাহারের আপনার কোড প্রচুর সময় দেয় নেটওয়ার্কের আচরণ যে কোন ধরণের সঙ্গে লেনদেন করছেনActivity রেফারেন্স।

নীচের সমাধানে, আমি ডাকে একটি ছোট পরিচালনা ক্লাস ঘোষণা করি ActivityBuffer। মূলত, এটি classকোনও মালিকানার একটি নির্ভরযোগ্য রেফারেন্স বজায় রাখা Activityএবং যখনই কোনও বৈধ রেফারেন্স উপলব্ধ থাকে তখন Runnableকোনও বৈধ Activityপ্রসঙ্গের মধ্যে গুলি চালানোর প্রতিশ্রুতি দেয় । Runnableগুলি UI 'তে থ্রেড অবিলম্বে যদি উপর সঞ্চালনের জন্য নির্ধারিত করা হয় Context, উপলভ্য যার এমন পর্যন্ত অন্যথায় সম্পাদন বিলম্বিত হয় Contextপ্রস্তুত।

/** A class which maintains a list of transactions to occur when Context becomes available. */
public final class ActivityBuffer {

    /** A class which defines operations to execute once there's an available Context. */
    public interface IRunnable {
        /** Executes when there's an available Context. Ideally, will it operate immediately. */
        void run(final Activity pActivity);
    }

    /* Member Variables. */
    private       Activity        mActivity;
    private final List<IRunnable> mRunnables;

    /** Constructor. */
    public ActivityBuffer() {
        // Initialize Member Variables.
        this.mActivity  = null;
        this.mRunnables = new ArrayList<IRunnable>();
    }

    /** Executes the Runnable if there's an available Context. Otherwise, defers execution until it becomes available. */
    public final void safely(final IRunnable pRunnable) {
        // Synchronize along the current instance.
        synchronized(this) {
            // Do we have a context available?
            if(this.isContextAvailable()) {
                // Fetch the Activity.
                final Activity lActivity = this.getActivity();
                // Execute the Runnable along the Activity.
                lActivity.runOnUiThread(new Runnable() { @Override public final void run() { pRunnable.run(lActivity); } });
            }
            else {
                // Buffer the Runnable so that it's ready to receive a valid reference.
                this.getRunnables().add(pRunnable);
            }
        }
    }

    /** Called to inform the ActivityBuffer that there's an available Activity reference. */
    public final void onContextGained(final Activity pActivity) {
        // Synchronize along ourself.
        synchronized(this) {
            // Update the Activity reference.
            this.setActivity(pActivity);
            // Are there any Runnables awaiting execution?
            if(!this.getRunnables().isEmpty()) {
                // Iterate the Runnables.
                for(final IRunnable lRunnable : this.getRunnables()) {
                    // Execute the Runnable on the UI Thread.
                    pActivity.runOnUiThread(new Runnable() { @Override public final void run() {
                        // Execute the Runnable.
                        lRunnable.run(pActivity);
                    } });
                }
                // Empty the Runnables.
                this.getRunnables().clear();
            }
        }
    }

    /** Called to inform the ActivityBuffer that the Context has been lost. */
    public final void onContextLost() {
        // Synchronize along ourself.
        synchronized(this) {
            // Remove the Context reference.
            this.setActivity(null);
        }
    }

    /** Defines whether there's a safe Context available for the ActivityBuffer. */
    public final boolean isContextAvailable() {
        // Synchronize upon ourself.
        synchronized(this) {
            // Return the state of the Activity reference.
            return (this.getActivity() != null);
        }
    }

    /* Getters and Setters. */
    private final void setActivity(final Activity pActivity) {
        this.mActivity = pActivity;
    }

    private final Activity getActivity() {
        return this.mActivity;
    }

    private final List<IRunnable> getRunnables() {
        return this.mRunnables;
    }

}

এর বাস্তবায়নের ক্ষেত্রে, পবন এম দ্বারা বর্ণিত আচরণের সাথে একযোগে জীবনচক্রের পদ্ধতিগুলি প্রয়োগ করার জন্য আমাদের অবশ্যই যত্ন নিতে হবে :

public class BaseFragment extends Fragment {

    /* Member Variables. */
    private ActivityBuffer mActivityBuffer;

    public BaseFragment() {
        // Implement the Parent.
        super();
        // Allocate the ActivityBuffer.
        this.mActivityBuffer = new ActivityBuffer();
    }

    @Override
    public final void onAttach(final Context pContext) {
        // Handle as usual.
        super.onAttach(pContext);
        // Is the Context an Activity?
        if(pContext instanceof Activity) {
            // Cast Accordingly.
            final Activity lActivity = (Activity)pContext;
            // Inform the ActivityBuffer.
            this.getActivityBuffer().onContextGained(lActivity);
        }
    }

    @Deprecated @Override
    public final void onAttach(final Activity pActivity) {
        // Handle as usual.
        super.onAttach(pActivity);
        // Inform the ActivityBuffer.
        this.getActivityBuffer().onContextGained(pActivity);
    }

    @Override
    public final void onDetach() {
        // Handle as usual.
        super.onDetach();
        // Inform the ActivityBuffer.
        this.getActivityBuffer().onContextLost();
    }

    /* Getters. */
    public final ActivityBuffer getActivityBuffer() {
        return this.mActivityBuffer;
    }

}

অবশেষে, আপনার অভ্যন্তরের Fragmentযে কোনও অঞ্চলে প্রসারিত হয় BaseFragmentযে আপনি কোনও কল সম্পর্কে অবিশ্বস্ত রয়েছেন getActivity(), কেবল একটি কল করুন this.getActivityBuffer().safely(...)এবং একটি ঘোষণা করুনActivityBuffer.IRunnable জন্য !

আপনার সামগ্রীগুলি void run(final Activity pActivity)তখন ইউআই থ্রেড বরাবর চালানোর গ্যারান্টিযুক্ত।

এর ActivityBufferপরে ক্যানটি নিম্নরূপ ব্যবহার করা যেতে পারে:

this.getActivityBuffer().safely(
  new ActivityBuffer.IRunnable() {
    @Override public final void run(final Activity pActivity) {
       // Do something with guaranteed Context.
    }
  }
);

Comments

আপনি এই .getActivityBuffer () নিরাপদে (...) পদ্ধতি ব্যবহার করার উদাহরণ যুক্ত করতে পারেন।

— ফাহাদ_সুস্ত

Answer 6

@Override
public void onActivityCreated(Bundle savedInstanceState) {
    super.onActivityCreated(savedInstanceState);
    // run the code making use of getActivity() from here
}

Comments

আপনি যে উত্তরটি সরবরাহ করেন সে সম্পর্কে আরও কিছু বিবরণ যুক্ত করে আরও উত্তর দিতে পারেন?

— অ্যারিসোন

Answer 7

আমি জানি এটি একটি পুরানো প্রশ্ন তবে আমি মনে করি এটি অবশ্যই আমার উত্তর দিতে হবে কারণ আমার সমস্যা অন্যদের দ্বারা সমাধান করা হয়নি।

প্রথমত: আমি গতিশীলভাবে টুকরো যোগ করছিলাম টুকরো টুকরো টুকরো ব্যবহার করে। দ্বিতীয়: আমার টুকরোগুলি AsyncTasks (কোনও সার্ভারে ডিবি কোয়েরি) ব্যবহার করে সংশোধিত হয়েছিল। তৃতীয়: ক্রিয়াকলাপ শুরুর সময়টিতে আমার খণ্ডটি তাত্ক্ষণিকভাবে চালু করা হয়নি চতুর্থ: আমি খণ্ডের ভেরিয়েবলটি পেতে একটি কাস্টম টুকরা ইনস্ট্যান্টেশন "এটি তৈরি বা লোড করুন" ব্যবহার করেছি। চতুর্থ: ওরিয়েন্টেশন পরিবর্তনের কারণে ক্রিয়াকলাপটি পুনরায় তৈরি করা হয়েছিল

সমস্যাটি হ'ল আমি প্রশ্নের উত্তরের কারণে খণ্ডটি "অপসারণ" করতে চেয়েছিলাম, তবে খণ্ডটি ভুলভাবে তৈরি করা হয়েছিল ঠিক আগে। আমি জানি না, সম্ভবত "প্রতিশ্রুতিবদ্ধ" কারণটি পরে করা হয়েছিল, খণ্ডটি অপসারণের সময় হওয়ার পরে এখনও যোগ করা হয়নি। অতএব getActivity () বাতিল হয়ে যাচ্ছিল।

সমাধান: 1) আমাকে পরীক্ষা করে দেখতে হয়েছিল যে নতুনটি তৈরির আগে আমি খণ্ডটির প্রথম উদাহরণটি সঠিকভাবে সন্ধান করার চেষ্টা করছিলাম 2) ওরিয়েন্টেশন পরিবর্তনের মাধ্যমে রাখার জন্য আমাকে সেই টুকরাটিতে serRetainInstance (সত্য) লাগাতে হয়েছিল (কোনও ব্যাকস্ট্যাক নেই) কোনও সমস্যা নেই) 3) "এটি মুছে ফেলুন" এর ঠিক আগে "পুনরায় পুনরুদ্ধার করা বা পুরানো টুকরা পাওয়ার" পরিবর্তে আমি খণ্ডটি সরাসরি ক্রিয়াকলাপের শুরুতে রেখেছি। এটিকে ক্রিয়াকলাপে "লোডিং" (বা তাত্ক্ষণিকভাবে) এর পরিবর্তে খণ্ড পরিবর্তনশীলটিকে সরানোর আগে এটিকে ইনস্ট্যান্ট করা গেটঅ্যাক্টিভিটির সমস্যাগুলি প্রতিরোধ করে।

Answer 8

কোটলিনে আপনি getActivity () নাল শর্তটি পরিচালনা করতে এই পদ্ধতিতে চেষ্টা করতে পারেন।

   activity.let { // activity == getActivity() in java

        //your code here

   }

এটি ক্রিয়াকলাপটি বাতিল বা না এবং যদি নাল না হয় তবে অভ্যন্তরীণ কোডটি কার্যকর করবে check