Examples with Messenger android.os.Messenger used on opensource projects

Example 61 with Messenger

use of android.os.Messenger in project platform_frameworks_base by android.

the class AsyncChannel method connected.

/**
     * Connect handler to messenger. This method is typically called
     * when a server receives a CMD_CHANNEL_FULL_CONNECTION request
     * and initializes the internal instance variables to allow communication
     * with the dstMessenger.
     *
     * @param srcContext
     * @param srcHandler
     * @param dstMessenger
     */
public void connected(Context srcContext, Handler srcHandler, Messenger dstMessenger) {
    if (DBG)
        log("connected srcHandler to the dstMessenger  E");
    // Initialize source fields
    mSrcContext = srcContext;
    mSrcHandler = srcHandler;
    mSrcMessenger = new Messenger(mSrcHandler);
    // Initialize destination fields
    mDstMessenger = dstMessenger;
    linkToDeathMonitor();
    if (DBG)
        log("connected srcHandler to the dstMessenger X");
}

Example 62 with Messenger

use of android.os.Messenger in project platform_frameworks_base by android.

the class AsyncChannel method connectSrcHandlerToPackageSync.

/**
     * Connect handler to named package/class synchronously.
     *
     * @param srcContext is the context of the source
     * @param srcHandler is the hander to receive CONNECTED & DISCONNECTED
     *            messages
     * @param dstPackageName is the destination package name
     * @param dstClassName is the fully qualified class name (i.e. contains
     *            package name)
     *
     * @return STATUS_SUCCESSFUL on success any other value is an error.
     */
public int connectSrcHandlerToPackageSync(Context srcContext, Handler srcHandler, String dstPackageName, String dstClassName) {
    if (DBG)
        log("connect srcHandler to dst Package & class E");
    mConnection = new AsyncChannelConnection();
    /* Initialize the source information */
    mSrcContext = srcContext;
    mSrcHandler = srcHandler;
    mSrcMessenger = new Messenger(srcHandler);
    /*
         * Initialize destination information to null they will
         * be initialized when the AsyncChannelConnection#onServiceConnected
         * is called
         */
    mDstMessenger = null;
    /* Send intent to create the connection */
    Intent intent = new Intent(Intent.ACTION_MAIN);
    intent.setClassName(dstPackageName, dstClassName);
    boolean result = srcContext.bindService(intent, mConnection, Context.BIND_AUTO_CREATE);
    if (DBG)
        log("connect srcHandler to dst Package & class X result=" + result);
    return result ? STATUS_SUCCESSFUL : STATUS_BINDING_UNSUCCESSFUL;
}

Example 63 with Messenger

use of android.os.Messenger in project platform_frameworks_base by android.

the class AsyncService method onCreate.

/**
     * onCreate
     */
@Override
public void onCreate() {
    super.onCreate();
    mAsyncServiceInfo = createHandler();
    mHandler = mAsyncServiceInfo.mHandler;
    mMessenger = new Messenger(mHandler);
}

Example 64 with Messenger

use of android.os.Messenger in project android_frameworks_base by ParanoidAndroid.

the class GlobalActions method takeScreenshot.

private void takeScreenshot() {
    synchronized (mScreenshotLock) {
        if (mScreenshotConnection != null) {
            return;
        }
        ComponentName cn = new ComponentName("com.android.systemui", "com.android.systemui.screenshot.TakeScreenshotService");
        Intent intent = new Intent();
        intent.setComponent(cn);
        ServiceConnection conn = new ServiceConnection() {

            @Override
            public void onServiceConnected(ComponentName name, IBinder service) {
                synchronized (mScreenshotLock) {
                    if (mScreenshotConnection != this) {
                        return;
                    }
                    Messenger messenger = new Messenger(service);
                    Message msg = Message.obtain(null, 1);
                    final ServiceConnection myConn = this;
                    Handler h = new Handler(mHandler.getLooper()) {

                        @Override
                        public void handleMessage(Message msg) {
                            synchronized (mScreenshotLock) {
                                if (mScreenshotConnection == myConn) {
                                    mContext.unbindService(mScreenshotConnection);
                                    mScreenshotConnection = null;
                                    mHandler.removeCallbacks(mScreenshotTimeout);
                                }
                            }
                        }
                    };
                    msg.replyTo = new Messenger(h);
                    msg.arg1 = msg.arg2 = 0;
                    /* wait for the dialog box to close */
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException ie) {
                    }
                    /* take the screenshot */
                    try {
                        messenger.send(msg);
                    } catch (RemoteException e) {
                    }
                }
            }

            @Override
            public void onServiceDisconnected(ComponentName name) {
            }
        };
        if (mContext.bindService(intent, conn, Context.BIND_AUTO_CREATE)) {
            mScreenshotConnection = conn;
            mHandler.postDelayed(mScreenshotTimeout, 10000);
        }
    }
}

Example 65 with Messenger

use of android.os.Messenger in project android_frameworks_base by ParanoidAndroid.

the class NsdManager method init.

/**
     * Initialize AsyncChannel
     */
private void init() {
    final Messenger messenger = getMessenger();
    if (messenger == null)
        throw new RuntimeException("Failed to initialize");
    HandlerThread t = new HandlerThread("NsdManager");
    t.start();
    mHandler = new ServiceHandler(t.getLooper());
    mAsyncChannel.connect(mContext, mHandler, messenger);
    try {
        mConnected.await();
    } catch (InterruptedException e) {
        Log.e(TAG, "interrupted wait at init");
    }
}