उदाहरण: मैसेजिंग का उपयोग करके गतिविधि और सेवा के बीच संचार

Question

मुझे किसी गतिविधि और सेवा के बीच संदेश भेजने का कोई उदाहरण नहीं मिल सकता है, और मैंने इसे पूरा करने में कई घंटे बिताए हैं। यहाँ दूसरों के लिए संदर्भ के लिए एक उदाहरण परियोजना है।

यह उदाहरण आपको किसी सेवा को सीधे शुरू या बंद करने की अनुमति देता है, और सेवा से अलग से बाँध / unbind करता है। जब सेवा चल रही होती है, तो यह 10 हर्ट्ज पर एक नंबर बढ़ाता है। यदि गतिविधि के लिए बाध्य है Service, तो यह वर्तमान मूल्य प्रदर्शित करेगा। डेटा को एक पूर्णांक के रूप में और एक स्ट्रिंग के रूप में स्थानांतरित किया जाता है ताकि आप देख सकें कि कैसे दो अलग-अलग तरीके हैं। सेवा में संदेश भेजने के लिए गतिविधि में बटन भी हैं (वेतन वृद्धि मूल्य में परिवर्तन)।

स्क्रीनशॉट:

AndroidManifest.xml:

<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
      package="com.exampleservice"
      android:versionCode="1"
      android:versionName="1.0">
    <application android:icon="@drawable/icon" android:label="@string/app_name">
        <activity android:name=".MainActivity"
                  android:label="@string/app_name">
            <intent-filter>
                <action android:name="android.intent.action.MAIN" />
                <category android:name="android.intent.category.LAUNCHER" />
            </intent-filter>
        </activity>
    <service android:name=".MyService"></service>
    </application>
    <uses-sdk android:minSdkVersion="8" />
</manifest>

रेस \ मूल्यों \ strings.xml:

<?xml version="1.0" encoding="utf-8"?>
<resources>
    <string name="app_name">ExampleService</string>
    <string name="service_started">Example Service started</string>
    <string name="service_label">Example Service Label</string>
</resources>

रेस \ लेआउट \ main.xml:

<RelativeLayout
    android:id="@+id/RelativeLayout01"
    android:layout_width="fill_parent"
    android:layout_height="wrap_content" >

    <Button
        android:id="@+id/btnStart"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="Start Service" >
    </Button>

    <Button
        android:id="@+id/btnStop"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:layout_alignParentRight="true"
        android:text="Stop Service" >
    </Button>
</RelativeLayout>

<RelativeLayout
    android:id="@+id/RelativeLayout02"
    android:layout_width="fill_parent"
    android:layout_height="wrap_content" >

    <Button
        android:id="@+id/btnBind"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="Bind to Service" >
    </Button>

    <Button
        android:id="@+id/btnUnbind"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:layout_alignParentRight="true"
        android:text="Unbind from Service" >
    </Button>
</RelativeLayout>

<TextView
    android:id="@+id/textStatus"
    android:layout_width="fill_parent"
    android:layout_height="wrap_content"
    android:text="Status Goes Here"
    android:textSize="24sp" />

<TextView
    android:id="@+id/textIntValue"
    android:layout_width="fill_parent"
    android:layout_height="wrap_content"
    android:text="Integer Value Goes Here"
    android:textSize="24sp" />

<TextView
    android:id="@+id/textStrValue"
    android:layout_width="fill_parent"
    android:layout_height="wrap_content"
    android:text="String Value Goes Here"
    android:textSize="24sp" />

<RelativeLayout
    android:id="@+id/RelativeLayout03"
    android:layout_width="fill_parent"
    android:layout_height="wrap_content" >

    <Button
        android:id="@+id/btnUpby1"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="Increment by 1" >
    </Button>

    <Button
        android:id="@+id/btnUpby10"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:layout_alignParentRight="true"
        android:text="Increment by 10" >
    </Button>
</RelativeLayout>

src \ com.exampleservice \ MainActivity.java:

package com.exampleservice;

import android.app.Activity;
import android.content.ComponentName;
import android.content.Context;
import android.content.Intent;
import android.content.ServiceConnection;
import android.os.Bundle;
import android.os.Handler;
import android.os.IBinder;
import android.os.Message;
import android.os.Messenger;
import android.os.RemoteException;
import android.util.Log;
import android.view.View;
import android.view.View.OnClickListener;
import android.widget.Button;
import android.widget.TextView;

public class MainActivity extends Activity {
    Button btnStart, btnStop, btnBind, btnUnbind, btnUpby1, btnUpby10;
    TextView textStatus, textIntValue, textStrValue;
    Messenger mService = null;
    boolean mIsBound;
    final Messenger mMessenger = new Messenger(new IncomingHandler());

    class IncomingHandler extends Handler {
        @Override
        public void handleMessage(Message msg) {
            switch (msg.what) {
            case MyService.MSG_SET_INT_VALUE:
                textIntValue.setText("Int Message: " + msg.arg1);
                break;
            case MyService.MSG_SET_STRING_VALUE:
                String str1 = msg.getData().getString("str1");
                textStrValue.setText("Str Message: " + str1);
                break;
            default:
                super.handleMessage(msg);
            }
        }
    }
    private ServiceConnection mConnection = new ServiceConnection() {
        public void onServiceConnected(ComponentName className, IBinder service) {
            mService = new Messenger(service);
            textStatus.setText("Attached.");
            try {
                Message msg = Message.obtain(null, MyService.MSG_REGISTER_CLIENT);
                msg.replyTo = mMessenger;
                mService.send(msg);
            }
            catch (RemoteException e) {
                // In this case the service has crashed before we could even do anything with it
            }
        }

        public void onServiceDisconnected(ComponentName className) {
            // This is called when the connection with the service has been unexpectedly disconnected - process crashed.
            mService = null;
            textStatus.setText("Disconnected.");
        }
    };

    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.main);
        btnStart = (Button)findViewById(R.id.btnStart);
        btnStop = (Button)findViewById(R.id.btnStop);
        btnBind = (Button)findViewById(R.id.btnBind);
        btnUnbind = (Button)findViewById(R.id.btnUnbind);
        textStatus = (TextView)findViewById(R.id.textStatus);
        textIntValue = (TextView)findViewById(R.id.textIntValue);
        textStrValue = (TextView)findViewById(R.id.textStrValue);
        btnUpby1 = (Button)findViewById(R.id.btnUpby1);
        btnUpby10 = (Button)findViewById(R.id.btnUpby10);

        btnStart.setOnClickListener(btnStartListener);
        btnStop.setOnClickListener(btnStopListener);
        btnBind.setOnClickListener(btnBindListener);
        btnUnbind.setOnClickListener(btnUnbindListener);
        btnUpby1.setOnClickListener(btnUpby1Listener);
        btnUpby10.setOnClickListener(btnUpby10Listener);

        restoreMe(savedInstanceState);

        CheckIfServiceIsRunning();
    }

    @Override
    protected void onSaveInstanceState(Bundle outState) {
        super.onSaveInstanceState(outState);
        outState.putString("textStatus", textStatus.getText().toString());
        outState.putString("textIntValue", textIntValue.getText().toString());
        outState.putString("textStrValue", textStrValue.getText().toString());
    }
    private void restoreMe(Bundle state) {
        if (state!=null) {
            textStatus.setText(state.getString("textStatus"));
            textIntValue.setText(state.getString("textIntValue"));
            textStrValue.setText(state.getString("textStrValue"));
        }
    }
    private void CheckIfServiceIsRunning() {
        //If the service is running when the activity starts, we want to automatically bind to it.
        if (MyService.isRunning()) {
            doBindService();
        }
    }

    private OnClickListener btnStartListener = new OnClickListener() {
        public void onClick(View v){
            startService(new Intent(MainActivity.this, MyService.class));
        }
    };
    private OnClickListener btnStopListener = new OnClickListener() {
        public void onClick(View v){
            doUnbindService();
            stopService(new Intent(MainActivity.this, MyService.class));
        }
    };
    private OnClickListener btnBindListener = new OnClickListener() {
        public void onClick(View v){
            doBindService();
        }
    };
    private OnClickListener btnUnbindListener = new OnClickListener() {
        public void onClick(View v){
            doUnbindService();
        }
    };
    private OnClickListener btnUpby1Listener = new OnClickListener() {
        public void onClick(View v){
            sendMessageToService(1);
        }
    };
    private OnClickListener btnUpby10Listener = new OnClickListener() {
        public void onClick(View v){
            sendMessageToService(10);
        }
    };
    private void sendMessageToService(int intvaluetosend) {
        if (mIsBound) {
            if (mService != null) {
                try {
                    Message msg = Message.obtain(null, MyService.MSG_SET_INT_VALUE, intvaluetosend, 0);
                    msg.replyTo = mMessenger;
                    mService.send(msg);
                }
                catch (RemoteException e) {
                }
            }
        }
    }


    void doBindService() {
        bindService(new Intent(this, MyService.class), mConnection, Context.BIND_AUTO_CREATE);
        mIsBound = true;
        textStatus.setText("Binding.");
    }
    void doUnbindService() {
        if (mIsBound) {
            // If we have received the service, and hence registered with it, then now is the time to unregister.
            if (mService != null) {
                try {
                    Message msg = Message.obtain(null, MyService.MSG_UNREGISTER_CLIENT);
                    msg.replyTo = mMessenger;
                    mService.send(msg);
                }
                catch (RemoteException e) {
                    // There is nothing special we need to do if the service has crashed.
                }
            }
            // Detach our existing connection.
            unbindService(mConnection);
            mIsBound = false;
            textStatus.setText("Unbinding.");
        }
    }

    @Override
    protected void onDestroy() {
        super.onDestroy();
        try {
            doUnbindService();
        }
        catch (Throwable t) {
            Log.e("MainActivity", "Failed to unbind from the service", t);
        }
    }
}

src \ com.exampleservice \ MyService.java:

package com.exampleservice;

import java.util.ArrayList;
import java.util.Timer;
import java.util.TimerTask;

import android.app.Notification;
import android.app.NotificationManager;
import android.app.PendingIntent;
import android.app.Service;
import android.content.Intent;
import android.os.Bundle;
import android.os.Handler;
import android.os.IBinder;
import android.os.Message;
import android.os.Messenger;
import android.os.RemoteException;
import android.util.Log;

public class MyService extends Service {
    private NotificationManager nm;
    private Timer timer = new Timer();
    private int counter = 0, incrementby = 1;
    private static boolean isRunning = false;

    ArrayList<Messenger> mClients = new ArrayList<Messenger>(); // Keeps track of all current registered clients.
    int mValue = 0; // Holds last value set by a client.
    static final int MSG_REGISTER_CLIENT = 1;
    static final int MSG_UNREGISTER_CLIENT = 2;
    static final int MSG_SET_INT_VALUE = 3;
    static final int MSG_SET_STRING_VALUE = 4;
    final Messenger mMessenger = new Messenger(new IncomingHandler()); // Target we publish for clients to send messages to IncomingHandler.


    @Override
    public IBinder onBind(Intent intent) {
        return mMessenger.getBinder();
    }
    class IncomingHandler extends Handler { // Handler of incoming messages from clients.
        @Override
        public void handleMessage(Message msg) {
            switch (msg.what) {
            case MSG_REGISTER_CLIENT:
                mClients.add(msg.replyTo);
                break;
            case MSG_UNREGISTER_CLIENT:
                mClients.remove(msg.replyTo);
                break;
            case MSG_SET_INT_VALUE:
                incrementby = msg.arg1;
                break;
            default:
                super.handleMessage(msg);
            }
        }
    }
    private void sendMessageToUI(int intvaluetosend) {
        for (int i=mClients.size()-1; i>=0; i--) {
            try {
                // Send data as an Integer
                mClients.get(i).send(Message.obtain(null, MSG_SET_INT_VALUE, intvaluetosend, 0));

                //Send data as a String
                Bundle b = new Bundle();
                b.putString("str1", "ab" + intvaluetosend + "cd");
                Message msg = Message.obtain(null, MSG_SET_STRING_VALUE);
                msg.setData(b);
                mClients.get(i).send(msg);

            }
            catch (RemoteException e) {
                // The client is dead. Remove it from the list; we are going through the list from back to front so this is safe to do inside the loop.
                mClients.remove(i);
            }
        }
    }

    @Override
    public void onCreate() {
        super.onCreate();
        Log.i("MyService", "Service Started.");
        showNotification();
        timer.scheduleAtFixedRate(new TimerTask(){ public void run() {onTimerTick();}}, 0, 100L);
        isRunning = true;
    }
    private void showNotification() {
        nm = (NotificationManager)getSystemService(NOTIFICATION_SERVICE);
        // In this sample, we'll use the same text for the ticker and the expanded notification
        CharSequence text = getText(R.string.service_started);
        // Set the icon, scrolling text and timestamp
        Notification notification = new Notification(R.drawable.icon, text, System.currentTimeMillis());
        // The PendingIntent to launch our activity if the user selects this notification
        PendingIntent contentIntent = PendingIntent.getActivity(this, 0, new Intent(this, MainActivity.class), 0);
        // Set the info for the views that show in the notification panel.
        notification.setLatestEventInfo(this, getText(R.string.service_label), text, contentIntent);
        // Send the notification.
        // We use a layout id because it is a unique number.  We use it later to cancel.
        nm.notify(R.string.service_started, notification);
    }
    @Override
    public int onStartCommand(Intent intent, int flags, int startId) {
        Log.i("MyService", "Received start id " + startId + ": " + intent);
        return START_STICKY; // run until explicitly stopped.
    }

    public static boolean isRunning()
    {
        return isRunning;
    }


    private void onTimerTick() {
        Log.i("TimerTick", "Timer doing work." + counter);
        try {
            counter += incrementby;
            sendMessageToUI(counter);

        }
        catch (Throwable t) { //you should always ultimately catch all exceptions in timer tasks.
            Log.e("TimerTick", "Timer Tick Failed.", t);
        }
    }

    @Override
    public void onDestroy() {
        super.onDestroy();
        if (timer != null) {timer.cancel();}
        counter=0;
        nm.cancel(R.string.service_started); // Cancel the persistent notification.
        Log.i("MyService", "Service Stopped.");
        isRunning = false;
    }
}

Comments

महान उदाहरण! एक और अच्छी सुविधा: यदि आप अपनी सेवा android:process=:myservicenameके serviceटैग के लिए विशेषता को अपने घोषणापत्र में रखते हैं। जैसे:, <service android:name="sname" android:process=":myservicename" />तो यह आपकी सेवा को एक अलग प्रक्रिया के रूप में चलाएगा - इस प्रकार एक अलग सूत्र में। इसका मतलब है, कि सेवा द्वारा किसी भी भारी गणना / लंबे अनुरोध ने आपके यूआई धागे को लटका नहीं दिया है।

— sydd

मुझे पता है कि आपने ऐसा करने के लिए प्रयास किया था, लेकिन इसे जीथब या इसी तरह के स्रोत-कोड साझा करने वाली साइट पर डालने और यहां लिंक पोस्ट करने के लिए अधिक समझदारी होगी। लोगों के लिए इसे प्राप्त करना और इस तरह से चलाना आसान है।

— एहतेश चौधरी

अच्छा उदाहरण। मैं इस कोड को एक ऑनलाइन रेपो (मामूली संशोधनों के साथ) में उन लोगों के लिए डालता हूं जो क्लोन करना चाहते हैं: bitbucket.org/alexfu/androidserviceexample/src

— एलेक्स फू

मैसेजिंग वास्तव में केवल तभी आवश्यक है जब आपकी सेवा को अन्य एप्लिकेशन द्वारा कॉल किया जा सके। अन्यथा आप एक बाइंडर के साथ चिपक सकते हैं जो आपको सेवा का एक संदर्भ देता है और बस इसके सार्वजनिक तरीकों को कॉल करता है।

— टाइप- a1pha

आपको सवाल बनाना चाहिए था और फिर सवाल का जवाब न देते हुए खुद ही जवाब तैयार करना चाहिए। महान उदाहरण हालांकि;)

— 7hi4g0

Answer 1

को देखो LocalService उदाहरण ।

आपका Serviceउन उपभोक्ताओं के लिए स्वयं का एक उदाहरण देता है जो कॉल करते हैं onBind। फिर आप सीधे सेवा के साथ बातचीत कर सकते हैं, जैसे कि सेवा के साथ अपने स्वयं के श्रोता इंटरफ़ेस को पंजीकृत करना, ताकि आप कॉलबैक प्राप्त कर सकें।

Comments

इसके साथ एकमात्र समस्या यह है कि यह मैसेंजर का उपयोग नहीं करेगा, इसलिए यह इस छद्म प्रश्न का उत्तर नहीं देगा। मैंने एक लोकल सेवा का उपयोग किया है, लेकिन मुझे एक मैसेंजर / हैंडलर का उदाहरण पाकर खुशी हुई। मुझे विश्वास नहीं है कि एक लोकल सर्विस को दूसरी प्रक्रिया में रखा जा सकता है।

— बेन

@ क्रिस्टोफर-ओर: मैं बहुत आभारी हूं कि आपने Android BroadcastReceiverट्यूटोरियल का लिंक पोस्ट किया है । मैंने LocalBroadcastManagerदो Activityउदाहरणों के बीच डेटा का लगातार आदान-प्रदान किया है ।

— डिर्क

इसके साथ समस्या LocalBroadcastManagerयह है कि यह गैर-अवरुद्ध है और आपको परिणामों के लिए इंतजार करना होगा। कभी-कभी आप तत्काल परिणाम चाहते हैं।

— TheRealChx101

यदि आपको मदद की मुझे इस सवाल के साथ कृपया कर सकते stackoverflow.com/questions/51508046/...

— राजेश कश्मीर

Answer 2

किसी सेवा में डेटा भेजने के लिए आप इसका उपयोग कर सकते हैं:

Intent intent = new Intent(getApplicationContext(), YourService.class);
intent.putExtra("SomeData","ItValue");
startService(intent);

और onStartCommand () में सेवा के बाद इरादे से डेटा प्राप्त करें।

किसी सेवा से डेटा या ईवेंट को किसी एप्लिकेशन पर भेजने के लिए (एक या अधिक गतिविधियों के लिए):

private void sendBroadcastMessage(String intentFilterName, int arg1, String extraKey) {
    Intent intent = new Intent(intentFilterName);
    if (arg1 != -1 && extraKey != null) {
        intent.putExtra(extraKey, arg1);
    }
    sendBroadcast(intent);
}

यह तरीका आपकी सेवा से कॉल कर रहा है। आप बस अपनी गतिविधि के लिए डेटा भेज सकते हैं।

private void someTaskInYourService(){

    //For example you downloading from server 1000 files
    for(int i = 0; i < 1000; i++) {
        Thread.sleep(5000) // 5 seconds. Catch in try-catch block
        sendBroadCastMessage(Events.UPDATE_DOWNLOADING_PROGRESSBAR, i,0,"up_download_progress");
    }

डेटा के साथ एक घटना प्राप्त करने के लिए, अपनी गतिविधि में विधि रजिस्टर करें और रजिस्टर करें।

private void registerBroadcastReceivers(){
    broadcastReceiver = new BroadcastReceiver() {
        @Override
        public void onReceive(Context context, Intent intent) {
            int arg1 = intent.getIntExtra("up_download_progress",0);
            progressBar.setProgress(arg1);
        }
    };
    IntentFilter progressfilter = new IntentFilter(Events.UPDATE_DOWNLOADING_PROGRESS);
    registerReceiver(broadcastReceiver,progressfilter);

अधिक डेटा भेजने के लिए, आप विधि को संशोधित कर सकते हैं sendBroadcastMessage();। याद रखें: आपको onResume () और unregister onStop () विधियों में प्रसारण पंजीकृत करना होगा!

अपडेट करें

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

1) ग्रीनबोट से EventBus

2) स्क्वायर इंक से ओटो

PS मैं अपने प्रोजेक्ट्स में केवल ग्रीनबॉट से EventBus का उपयोग कर रहा हूं,

Comments

मुझे कहां से आवर्ती में पंजीकरण करने की आवश्यकता होनी चाहिए और onStop में मुझे गतिविधि करने की आवश्यकता हो सकती है?

— user3233280

हाँ। सेवा से ईवेंट प्राप्त करने के लिए आपको प्रसारण में पंजीकृत होना चाहिए। याद रखें कि आपको onStop में अपंजीकृत प्रसारण करना होगा। अब, मैं अपने तरीके का उपयोग करने की सलाह नहीं देता। कृपया अन्य विचारों / गतिविधियों / सेवाओं जैसे कि EventBus github.com/greenrobot/EventBus या Otto github.com/square/otto

— a.black13

क्या आप मुझे

— बता

क्या Google ने इसके खिलाफ सिफारिश की है, या आप केवल इसे "गलत" कह रहे हैं क्योंकि आपको लगता है कि अन्य समाधान बेहतर हैं?

— केविन क्रुमिडेव जुले

प्लस लिंक प्रदान करने के लिए एक EventBusऔर Otto।

— मोहम्मद अली

Answer 3

नोट: आपको यह जांचने की आवश्यकता नहीं है कि आपकी सेवा चल रही है या नहीं CheckIfServiceIsRunning(), क्योंकि bindService()यदि यह नहीं चल रही है तो इसे शुरू कर देंगे।

इसके अलावा: यदि आप फोन को घुमाते हैं तो आप इसे bindService()फिर से नहीं चाहते हैं , क्योंकि onCreate()फिर से कॉल किया जाएगा। onConfigurationChanged()इसे रोकने के लिए परिभाषित करना सुनिश्चित करें।

Comments

मेरे मामले में, मुझे हर समय चलने वाली सेवा की आवश्यकता नहीं है। यदि गतिविधि शुरू होने पर सेवा पहले से ही चल रही है, तो मैं इसे बांधना चाहता हूं। यदि गतिविधि शुरू होने पर सेवा नहीं चल रही है, तो मैं सेवा को रोकना चाहता हूं।

— लांस लेफ्योर

मुझे यकीन नहीं है कि यह सच है, bindService सेवा शुरू नहीं करता है, क्या आप कृपया दस्तावेज़ को इंगित कर सकते हैं?

— कलिन

developer.android.com/reference/android/app/Service.html पहला पैराग्राफ कहता हैServices can be started with Context.startService() and Context.bindService()

— कोई कहीं

Answer 4

Message msg = Message.obtain(null, 2, 0, 0);
                    Bundle bundle = new Bundle();
                    bundle.putString("url", url);
                    bundle.putString("names", names);
                    bundle.putString("captions",captions); 
                    msg.setData(bundle);

इसलिए आप इसे सेवा में भेजें। बाद में प्राप्त करते हैं।

Answer 5

सब कुछ ठीक है । मैसेंजरactivity/service का उपयोग करके संचार का अच्छा उदाहरण ।

एक टिप्पणी: विधि MyService.isRunning()की आवश्यकता नहीं है .. bindService()कई बार किया जा सकता है। उस में कोई बुराई नहीं।

यदि MyService एक अलग प्रक्रिया में चल रही है, तो स्थैतिक फ़ंक्शन MyService.isRunning()हमेशा गलत होगा। इसलिए इस फ़ंक्शन की कोई आवश्यकता नहीं है।

Answer 6

इस तरह से मैंने अपनी गतिविधि पर गतिविधि-> सेवा संचार: को लागू कर दिया है

private static class MyResultReciever extends ResultReceiver {
     /**
     * Create a new ResultReceive to receive results.  Your
     * {@link #onReceiveResult} method will be called from the thread running
     * <var>handler</var> if given, or from an arbitrary thread if null.
     *
     * @param handler
     */
     public MyResultReciever(Handler handler) {
         super(handler);
     }

     @Override
     protected void onReceiveResult(int resultCode, Bundle resultData) {
         if (resultCode == 100) {
             //dostuff
         }
     }

और फिर मैंने अपनी सेवा शुरू करने के लिए इसका उपयोग किया

protected void onCreate(Bundle savedInstanceState) {
MyResultReciever resultReciever = new MyResultReciever(handler);
        service = new Intent(this, MyService.class);
        service.putExtra("receiver", resultReciever);
        startService(service);
}

मेरी सेवा में मेरे पास था

public int onStartCommand(Intent intent, int flags, int startId) {
    if (intent != null)
        resultReceiver = intent.getParcelableExtra("receiver");
    return Service.START_STICKY;
}

उम्मीद है की यह मदद करेगा

Answer 7

मुझे लगता है कि आप "कार्यान्वयन हैंडलर। कॉलबैक" के साथ अपनी गतिविधि की घोषणा करके कुछ स्मृति बचा सकते हैं

Answer 8

शानदार ट्यूटोरियल, शानदार प्रस्तुति। नीट, सरल, लघु और बहुत व्याख्यात्मक। हालाँकि, notification.setLatestEventInfo(this, getText(R.string.service_label), text, contentIntent);विधि अधिक नहीं है। जैसा कि ट्रेंट ने यहां कहा है , अच्छा तरीका होगा:

private static final int NOTIFICATION_ID = 45349;

private void showNotification() {
    NotificationCompat.Builder builder =
            new NotificationCompat.Builder(this)
                    .setSmallIcon(R.mipmap.ic_launcher)
                    .setContentTitle("My Notification Title")
                    .setContentText("Something interesting happened");

    Intent targetIntent = new Intent(this, MainActivity.class);
    PendingIntent contentIntent = PendingIntent.getActivity(this, 0, targetIntent, PendingIntent.FLAG_UPDATE_CURRENT);
    builder.setContentIntent(contentIntent);
    _nManager = (NotificationManager) getSystemService(Context.NOTIFICATION_SERVICE);
    _nManager.notify(NOTIFICATION_ID, builder.build());
}

@Override
public void onDestroy() {
    super.onDestroy();
    if (_timer != null) {_timer.cancel();}
    _counter=0;
    _nManager.cancel(NOTIFICATION_ID); // Cancel the persistent notification.
    Log.i("PlaybackService", "Service Stopped.");
    _isRunning = false;
}

खुद की जाँच की, सब कुछ एक आकर्षण की तरह काम करता है (गतिविधि और सेवा के नाम मूल से भिन्न हो सकते हैं)।

Answer 9

मैंने सभी उत्तर देखे हैं। मैं अब एक दिन सबसे मजबूत तरीका बताना चाहता हूं । जो आपको Activity - Service - Dialog - Fragments(सब कुछ) के बीच संवाद स्थापित करेगा ।

EventBus

मेरी परियोजनाओं में उपयोग होने वाले इस परिवाद में मैसेजिंग से संबंधित महान विशेषताएं हैं।

EventBus 3 चरणों में

1. घटनाओं को परिभाषित करें:

   public static class MessageEvent { /* Additional fields if needed */ }

2. ग्राहक तैयार करें:

अपनी सदस्यता विधि की घोषणा और व्याख्या करें, वैकल्पिक रूप से एक थ्रेड मोड निर्दिष्ट करें :

@Subscribe(threadMode = ThreadMode.MAIN) 
public void onMessageEvent(MessageEvent event) {/* Do something */};

रजिस्टर करें और अपने ग्राहक को अपंजीकृत करें। उदाहरण के लिए, एंड्रॉइड पर गतिविधियों और टुकड़ों को आमतौर पर उनके जीवन चक्र के अनुसार पंजीकृत होना चाहिए:

@Override
public void onStart() {
    super.onStart();
    EventBus.getDefault().register(this);
}

@Override
public void onStop() {
    super.onStop();
    EventBus.getDefault().unregister(this);
}

3. घटनाएँ पोस्ट करें:

   EventBus.getDefault().post(new MessageEvent());

बस इस निर्भरता को अपने ऐप लेवल ग्रेडेल में जोड़ें

compile 'org.greenrobot:eventbus:3.1.1'