Example usage for android.os RemoteException toString

List of usage examples for android.os RemoteException toString

Introduction

In this page you can find the example usage for android.os RemoteException toString.

Prototype

public String toString() 

Source Link

Document

Returns a short description of this throwable.

Usage

From source file:com.sentaroh.android.TaskAutomation.Config.ActivityMain.java

final private void unbindScheduler() {
    mGlblParms.util.addDebugMsg(1, "I", "unbindScheduler entered");
    if (mSvcClientCallback != null) {
        try {//  ww  w.  ja v a  2  s  . co  m
            if (mSvcServer != null)
                mSvcServer.removeCallBack(mSvcClientCallback);
            mSvcClientCallback = null;
        } catch (RemoteException e) {
            e.printStackTrace();
            mGlblParms.util.addLogMsg("E", "removeListener error :" + e.toString());
        }
    }
    unbindService(mSvcConnScheduler);
}

From source file:com.sentaroh.android.TaskAutomation.Config.ActivityMain.java

final private void setCallbackListener() {
    mGlblParms.util.addDebugMsg(1, "I", "setCallbackListener entered");
    mSvcClientCallback = new ISchedulerCallback.Stub() {
        final public void notifyToClient(String resp_time, final String resp, final String grp,
                final String task, final String action, String dialog_id, final int atc, final int resp_cd,
                final String msg) throws RemoteException {
            if (mEnvParms.settingDebugLevel >= 2)
                mGlblParms.util.addDebugMsg(2, "I", "Notify received ", "Resp=", resp, ", Task=", task,
                        ", action=", action, ", " + "dialog_id=", dialog_id);
            handler.post(new Runnable() {
                @Override/*from  w  ww.j a va  2  s  .  c  o m*/
                public void run() {
                    refreshActiveTaskStatus(atc);
                }
            });
        }
    };
    try {
        mSvcServer.setCallBack(mSvcClientCallback);
    } catch (RemoteException e) {
        e.printStackTrace();
        mGlblParms.util.addLogMsg("E", "setCallbackListener error :" + e.toString());
    }
}

From source file:com.android.contacts.ContactSaveService.java

private void saveContact(Intent intent) {
    RawContactDeltaList state = intent.getParcelableExtra(EXTRA_CONTACT_STATE);
    boolean isProfile = intent.getBooleanExtra(EXTRA_SAVE_IS_PROFILE, false);
    Bundle updatedPhotos = intent.getParcelableExtra(EXTRA_UPDATED_PHOTOS);

    if (state == null) {
        Log.e(TAG, "Invalid arguments for saveContact request");
        return;//from   www .  jav  a  2 s.  com
    }

    int saveMode = intent.getIntExtra(EXTRA_SAVE_MODE, -1);
    // Trim any empty fields, and RawContacts, before persisting
    final AccountTypeManager accountTypes = AccountTypeManager.getInstance(this);
    RawContactModifier.trimEmpty(state, accountTypes);

    Uri lookupUri = null;

    final ContentResolver resolver = getContentResolver();

    boolean succeeded = false;

    // Keep track of the id of a newly raw-contact (if any... there can be at most one).
    long insertedRawContactId = -1;

    // Attempt to persist changes
    int tries = 0;
    while (tries++ < PERSIST_TRIES) {
        try {
            // Build operations and try applying
            final ArrayList<CPOWrapper> diffWrapper = state.buildDiffWrapper();

            final ArrayList<ContentProviderOperation> diff = Lists.newArrayList();

            for (CPOWrapper cpoWrapper : diffWrapper) {
                diff.add(cpoWrapper.getOperation());
            }

            if (DEBUG) {
                Log.v(TAG, "Content Provider Operations:");
                for (ContentProviderOperation operation : diff) {
                    Log.v(TAG, operation.toString());
                }
            }

            int numberProcessed = 0;
            boolean batchFailed = false;
            final ContentProviderResult[] results = new ContentProviderResult[diff.size()];
            while (numberProcessed < diff.size()) {
                final int subsetCount = applyDiffSubset(diff, numberProcessed, results, resolver);
                if (subsetCount == -1) {
                    Log.w(TAG, "Resolver.applyBatch failed in saveContacts");
                    batchFailed = true;
                    break;
                } else {
                    numberProcessed += subsetCount;
                }
            }

            if (batchFailed) {
                // Retry save
                continue;
            }

            final long rawContactId = getRawContactId(state, diffWrapper, results);
            if (rawContactId == -1) {
                throw new IllegalStateException("Could not determine RawContact ID after save");
            }
            // We don't have to check to see if the value is still -1.  If we reach here,
            // the previous loop iteration didn't succeed, so any ID that we obtained is bogus.
            insertedRawContactId = getInsertedRawContactId(diffWrapper, results);
            if (isProfile) {
                // Since the profile supports local raw contacts, which may have been completely
                // removed if all information was removed, we need to do a special query to
                // get the lookup URI for the profile contact (if it still exists).
                Cursor c = resolver.query(Profile.CONTENT_URI,
                        new String[] { Contacts._ID, Contacts.LOOKUP_KEY }, null, null, null);
                if (c == null) {
                    continue;
                }
                try {
                    if (c.moveToFirst()) {
                        final long contactId = c.getLong(0);
                        final String lookupKey = c.getString(1);
                        lookupUri = Contacts.getLookupUri(contactId, lookupKey);
                    }
                } finally {
                    c.close();
                }
            } else {
                final Uri rawContactUri = ContentUris.withAppendedId(RawContacts.CONTENT_URI, rawContactId);
                lookupUri = RawContacts.getContactLookupUri(resolver, rawContactUri);
            }
            if (lookupUri != null && Log.isLoggable(TAG, Log.VERBOSE)) {
                Log.v(TAG, "Saved contact. New URI: " + lookupUri);
            }

            // We can change this back to false later, if we fail to save the contact photo.
            succeeded = true;
            break;

        } catch (RemoteException e) {
            // Something went wrong, bail without success
            FeedbackHelper.sendFeedback(this, TAG, "Problem persisting user edits", e);
            break;

        } catch (IllegalArgumentException e) {
            // This is thrown by applyBatch on malformed requests
            FeedbackHelper.sendFeedback(this, TAG, "Problem persisting user edits", e);
            showToast(R.string.contactSavedErrorToast);
            break;

        } catch (OperationApplicationException e) {
            // Version consistency failed, re-parent change and try again
            Log.w(TAG, "Version consistency failed, re-parenting: " + e.toString());
            final StringBuilder sb = new StringBuilder(RawContacts._ID + " IN(");
            boolean first = true;
            final int count = state.size();
            for (int i = 0; i < count; i++) {
                Long rawContactId = state.getRawContactId(i);
                if (rawContactId != null && rawContactId != -1) {
                    if (!first) {
                        sb.append(',');
                    }
                    sb.append(rawContactId);
                    first = false;
                }
            }
            sb.append(")");

            if (first) {
                throw new IllegalStateException("Version consistency failed for a new contact", e);
            }

            final RawContactDeltaList newState = RawContactDeltaList.fromQuery(
                    isProfile ? RawContactsEntity.PROFILE_CONTENT_URI : RawContactsEntity.CONTENT_URI, resolver,
                    sb.toString(), null, null);
            state = RawContactDeltaList.mergeAfter(newState, state);

            // Update the new state to use profile URIs if appropriate.
            if (isProfile) {
                for (RawContactDelta delta : state) {
                    delta.setProfileQueryUri();
                }
            }
        }
    }

    // Now save any updated photos.  We do this at the end to ensure that
    // the ContactProvider already knows about newly-created contacts.
    if (updatedPhotos != null) {
        for (String key : updatedPhotos.keySet()) {
            Uri photoUri = updatedPhotos.getParcelable(key);
            long rawContactId = Long.parseLong(key);

            // If the raw-contact ID is negative, we are saving a new raw-contact;
            // replace the bogus ID with the new one that we actually saved the contact at.
            if (rawContactId < 0) {
                rawContactId = insertedRawContactId;
            }

            // If the save failed, insertedRawContactId will be -1
            if (rawContactId < 0 || !saveUpdatedPhoto(rawContactId, photoUri, saveMode)) {
                succeeded = false;
            }
        }
    }

    Intent callbackIntent = intent.getParcelableExtra(EXTRA_CALLBACK_INTENT);
    if (callbackIntent != null) {
        if (succeeded) {
            // Mark the intent to indicate that the save was successful (even if the lookup URI
            // is now null).  For local contacts or the local profile, it's possible that the
            // save triggered removal of the contact, so no lookup URI would exist..
            callbackIntent.putExtra(EXTRA_SAVE_SUCCEEDED, true);
        }
        callbackIntent.setData(lookupUri);
        deliverCallback(callbackIntent);
    }
}

From source file:com.sentaroh.android.SMBSync2.ActivityMain.java

final private void setCallbackListener() {
    util.addDebugMsg(1, "I", "setCallbackListener entered");
    try {//from w  ww. j a v a  2  s  .c om
        mSvcClient.setCallBack(mSvcCallbackStub);
    } catch (RemoteException e) {
        e.printStackTrace();
        util.addDebugMsg(0, "E", "setCallbackListener error :" + e.toString());
    }
}

From source file:com.sentaroh.android.SMBSync2.ActivityMain.java

final private void unsetCallbackListener() {
    if (mSvcClient != null) {
        try {/*from  w  w  w .j a  va2s  .  co m*/
            mSvcClient.removeCallBack(mSvcCallbackStub);
        } catch (RemoteException e) {
            e.printStackTrace();
            util.addDebugMsg(0, "E", "unsetCallbackListener error :" + e.toString());
        }
    }
}

From source file:com.sentaroh.android.SMBSync.SMBSyncMain.java

final private void setCallbackListener() {
    util.addDebugLogMsg(1, "I", "setCallbackListener entered");
    try {/*from www .  ja v  a  2 s. c  o  m*/
        mSvcClient.setCallBack(mSvcCallbackStub);
    } catch (RemoteException e) {
        e.printStackTrace();
        util.addDebugLogMsg(0, "E", "setCallbackListener error :" + e.toString());
    }
}

From source file:com.sentaroh.android.SMBSync.SMBSyncMain.java

final private void unsetCallbackListener() {
    if (mSvcClient != null) {
        try {//w w w  .ja va2  s.  c  om
            mSvcClient.removeCallBack(mSvcCallbackStub);
        } catch (RemoteException e) {
            e.printStackTrace();
            util.addDebugLogMsg(0, "E", "unsetCallbackListener error :" + e.toString());
        }
    }
}

From source file:com.piusvelte.taplock.client.core.TapLockService.java

@Override
public int onStartCommand(Intent intent, int flags, int startId) {
    if (intent != null) {
        String action = intent.getAction();
        if (BluetoothAdapter.ACTION_STATE_CHANGED.equals(action)) {
            int state = intent.getIntExtra(BluetoothAdapter.EXTRA_STATE, BluetoothAdapter.STATE_OFF);
            if (state == BluetoothAdapter.STATE_ON) {
                if (mStartedBT) {
                    if (mUIInterface != null) {
                        try {
                            mUIInterface.setMessage("Bluetooth enabled");
                        } catch (RemoteException e) {
                            Log.e(TAG, e.getMessage());
                        }/* w ww .j  a v  a  2  s.c o m*/
                    }
                    if ((mQueueAddress != null) && (mQueueState != null))
                        requestWrite(mQueueAddress, mQueueState, mQueuePassphrase);
                    else if (mRequestDiscovery && !mBtAdapter.isDiscovering())
                        mBtAdapter.startDiscovery();
                    else if (mUIInterface != null) {
                        try {
                            mUIInterface.setBluetoothEnabled();
                        } catch (RemoteException e) {
                            Log.e(TAG, e.getMessage());
                        }
                    }
                }
            } else if (state == BluetoothAdapter.STATE_TURNING_OFF) {
                if (mUIInterface != null) {
                    try {
                        mUIInterface.setMessage("Bluetooth disabled");
                    } catch (RemoteException e) {
                        Log.e(TAG, e.getMessage());
                    }
                }
                stopThreads();
            }
        } else if (BluetoothDevice.ACTION_FOUND.equals(action)) {
            // Get the BluetoothDevice object from the Intent
            BluetoothDevice device = intent.getParcelableExtra(BluetoothDevice.EXTRA_DEVICE);
            if (device.getBondState() == BluetoothDevice.BOND_BONDED) {
                // connect if configured
                String address = device.getAddress();
                for (JSONObject deviceJObj : mDevices) {
                    try {
                        if (deviceJObj.getString(KEY_ADDRESS).equals(address)) {
                            // if queued
                            mDeviceFound = (mQueueAddress != null) && mQueueAddress.equals(address)
                                    && (mQueueState != null);
                            break;
                        }
                    } catch (JSONException e) {
                        Log.e(TAG, e.getMessage());
                    }
                }
            } else if (mRequestDiscovery && (mUIInterface != null)) {
                String unpairedDevice = TapLock
                        .createDevice(device.getName(), device.getAddress(), DEFAULT_PASSPHRASE).toString();
                try {
                    mUIInterface.setUnpairedDevice(unpairedDevice);
                } catch (RemoteException e) {
                    Log.e(TAG, e.getMessage());
                }
            }
        } else if (BluetoothAdapter.ACTION_DISCOVERY_FINISHED.equals(action)) {
            if (mDeviceFound) {
                requestWrite(mQueueAddress, mQueueState, mQueuePassphrase);
                mDeviceFound = false;
            } else if (mRequestDiscovery) {
                mRequestDiscovery = false;
                if (mUIInterface != null) {
                    try {
                        mUIInterface.setDiscoveryFinished();
                    } catch (RemoteException e) {
                        Log.e(TAG, e.toString());
                    }
                }
            }
        } else if (ACTION_TOGGLE.equals(action) && intent.hasExtra(EXTRA_DEVICE_ADDRESS)) {
            String address = intent.getStringExtra(EXTRA_DEVICE_ADDRESS);
            requestWrite(address, ACTION_TOGGLE, null);
        } else if (AppWidgetManager.ACTION_APPWIDGET_UPDATE.equals(action)) {
            // create widget
            if (intent.hasExtra(AppWidgetManager.EXTRA_APPWIDGET_ID)) {
                int appWidgetId = intent.getIntExtra(AppWidgetManager.EXTRA_APPWIDGET_ID,
                        AppWidgetManager.INVALID_APPWIDGET_ID);
                if (intent.hasExtra(EXTRA_DEVICE_NAME)) {
                    // add a widget
                    String deviceName = intent.getStringExtra(EXTRA_DEVICE_NAME);
                    for (int i = 0, l = mDevices.size(); i < l; i++) {
                        String name = null;
                        try {
                            name = mDevices.get(i).getString(KEY_NAME);
                        } catch (JSONException e1) {
                            e1.printStackTrace();
                        }
                        if ((name != null) && name.equals(deviceName)) {
                            JSONObject deviceJObj = mDevices.remove(i);
                            JSONArray widgetsJArr;
                            if (deviceJObj.has(KEY_WIDGETS)) {
                                try {
                                    widgetsJArr = deviceJObj.getJSONArray(KEY_WIDGETS);
                                } catch (JSONException e) {
                                    widgetsJArr = new JSONArray();
                                }
                            } else
                                widgetsJArr = new JSONArray();
                            widgetsJArr.put(appWidgetId);
                            try {
                                deviceJObj.put(KEY_WIDGETS, widgetsJArr);
                            } catch (JSONException e) {
                                e.printStackTrace();
                            }
                            mDevices.add(i, deviceJObj);
                            TapLock.storeDevices(this, getSharedPreferences(KEY_PREFS, MODE_PRIVATE), mDevices);
                            break;
                        }
                    }
                }
                buildWidget(appWidgetId);
            } else if (intent.hasExtra(AppWidgetManager.EXTRA_APPWIDGET_IDS)) {
                int[] appWidgetIds = intent.getIntArrayExtra(AppWidgetManager.EXTRA_APPWIDGET_IDS);
                if (appWidgetIds != null) {
                    for (int appWidgetId : appWidgetIds)
                        buildWidget(appWidgetId);
                }
            }
        } else if (AppWidgetManager.ACTION_APPWIDGET_DELETED.equals(action)) {
            int appWidgetId = intent.getExtras().getInt(AppWidgetManager.EXTRA_APPWIDGET_ID,
                    AppWidgetManager.INVALID_APPWIDGET_ID);
            Log.d(TAG, "delete appWidgetId: " + appWidgetId);
            for (int i = 0, l = mDevices.size(); i < l; i++) {
                JSONObject deviceJObj = mDevices.get(i);
                if (deviceJObj.has(KEY_WIDGETS)) {
                    JSONArray widgetsJArr = null;
                    try {
                        widgetsJArr = deviceJObj.getJSONArray(KEY_WIDGETS);
                    } catch (JSONException e) {
                        e.printStackTrace();
                    }
                    if (widgetsJArr != null) {
                        boolean wasUpdated = false;
                        JSONArray newWidgetsJArr = new JSONArray();
                        for (int widgetIdx = 0, wdigetsLen = widgetsJArr
                                .length(); widgetIdx < wdigetsLen; widgetIdx++) {
                            int widgetId;
                            try {
                                widgetId = widgetsJArr.getInt(widgetIdx);
                            } catch (JSONException e) {
                                widgetId = AppWidgetManager.INVALID_APPWIDGET_ID;
                                e.printStackTrace();
                            }
                            Log.d(TAG, "eval widgetId: " + widgetId);
                            if ((widgetId != AppWidgetManager.INVALID_APPWIDGET_ID)
                                    && (widgetId == appWidgetId)) {
                                Log.d(TAG, "skip: " + widgetId);
                                wasUpdated = true;
                            } else {
                                Log.d(TAG, "include: " + widgetId);
                                newWidgetsJArr.put(widgetId);
                            }
                        }
                        if (wasUpdated) {
                            try {
                                deviceJObj.put(KEY_WIDGETS, newWidgetsJArr);
                                mDevices.remove(i);
                                mDevices.add(i, deviceJObj);
                                TapLock.storeDevices(this, getSharedPreferences(KEY_PREFS, MODE_PRIVATE),
                                        mDevices);
                                Log.d(TAG, "stored: " + deviceJObj.toString());
                            } catch (JSONException e) {
                                e.printStackTrace();
                            }
                        }
                    }
                } else {
                    JSONArray widgetsJArr = new JSONArray();
                    try {
                        deviceJObj.put(KEY_WIDGETS, widgetsJArr);
                        mDevices.remove(i);
                        mDevices.add(i, deviceJObj);
                        TapLock.storeDevices(this, getSharedPreferences(KEY_PREFS, MODE_PRIVATE), mDevices);
                    } catch (JSONException e) {
                        e.printStackTrace();
                    }
                }
            }
        }
    }
    return START_STICKY;
}