Java DataItemBuffer类代码示例

import com.google.android.gms.wearable.DataItemBuffer; //导入依赖的package包/类
/**
 * This method read the UART configurations from the DataApi and populates the adapter with them.
 */
private void populateConfigurations() {
	if (mGoogleApiClient.isConnected()) {
		final PendingResult<DataItemBuffer> results = Wearable.DataApi.getDataItems(mGoogleApiClient, Uri.parse("wear:" + Constants.UART.CONFIGURATIONS), DataApi.FILTER_PREFIX);
		results.setResultCallback(new ResultCallback<DataItemBuffer>() {
			@Override
			public void onResult(final DataItemBuffer dataItems) {
				final List<UartConfiguration> configurations = new ArrayList<>(dataItems.getCount());
				for (int i = 0; i < dataItems.getCount(); ++i) {
					final DataItem item = dataItems.get(i);
					final long id = ContentUris.parseId(item.getUri());
					final DataMap dataMap = DataMapItem.fromDataItem(item).getDataMap();
					final UartConfiguration configuration = new UartConfiguration(dataMap, id);
					configurations.add(configuration);
				}
				mAdapter.setConfigurations(configurations);
				dataItems.release();
			}
		});
	}
}
 

import com.google.android.gms.wearable.DataItemBuffer; //导入依赖的package包/类
@SuppressLint("CommitPrefEdits")
@Override
public void onResult(@NonNull DataItemBuffer dataItems) {
    // This is the callback from the getDataItems() call in resyncAll()
    SharedPreferences.Editor editor;
    if (TextUtils.isEmpty(sharedPrefsName)) {
        editor = PreferenceManager.getDefaultSharedPreferences(appContext).edit();
    } else {
        editor = appContext.getSharedPreferences(sharedPrefsName, MODE_PRIVATE).edit();
    }
    try {
        if (dataItems.getStatus().isSuccess()) {
            for (int i = dataItems.getCount() - 1; i >= 0; i--) {
                Log.d("PrefSyncService", "Resync onResult: " + dataItems.get(i));
                saveItem(dataItems.get(i), editor, null);
            }
        }
    } finally {
        // We don't use apply() because we don't know what thread we're on
        editor.commit();
        dataItems.release();
    }
}
 

import com.google.android.gms.wearable.DataItemBuffer; //导入依赖的package包/类
private void getAllAvailableDataItems() {
    PendingResult<DataItemBuffer> results = Wearable.DataApi.getDataItems(mGoogleApiClient);
    results.setResultCallback(new ResultCallback<DataItemBuffer>() {
        @Override
        public void onResult(@NonNull DataItemBuffer dataItems) {
            if (dataItems.getCount() != 0) {
                for (DataItem item : dataItems) {
                    if (item.getUri().getPath().contains(Statics.DATAIGC)) {
                        getStringFromAsset(item);
                    }
                    if (item.getUri().getPath().contains(Statics.DATATHROWABLE)) {
                        getExceptionFromWear(item);
                    }
                    if (item.getUri().getPath().contains(Statics.DATABTFAILED)) {
                        getBTFailed(item);
                    }
                }
            }
            dataItems.release();
        }
    });
}
 

import com.google.android.gms.wearable.DataItemBuffer; //导入依赖的package包/类
/**
 * Retrieves data items asynchronously. Caller can specify a {@link ResultCallback} or pass a
 * {@code null}; if a {@code null} is passed, a default {@link ResultCallback} will be used
 * that calls {@link DataConsumer#onGetDataItems(int, DataItemBuffer)}.
 *
 * @see DataConsumer#onGetDataItems(int, DataItemBuffer)
 */
public void getDataItems(@Nullable final ResultCallback<? super DataItemBuffer> callback) {
    assertApiConnectivity();
    Wearable.DataApi.getDataItems(mGoogleApiClient).setResultCallback(
            new ResultCallback<DataItemBuffer>() {
                @Override
                public void onResult(DataItemBuffer dataItems) {
                    try {
                        int statusCode = dataItems.getStatus().getStatusCode();
                        if (!dataItems.getStatus().isSuccess()) {
                            Log.e(TAG, "Failed to get items, status code: " + statusCode);
                        }
                        if (callback == null) {
                            for (DataConsumer consumer : mDataConsumers) {
                                consumer.onGetDataItems(statusCode, dataItems);
                            }
                        } else {
                            callback.onResult(dataItems);
                        }
                    } finally {
                        dataItems.release();
                    }
                }
            });
}
 

import com.google.android.gms.wearable.DataItemBuffer; //导入依赖的package包/类
@Override
public void onConnected(Bundle bundle) {
    Wearable.DataApi.addListener(mGoogleApiClient, this);

    // get existing data
    PendingResult<DataItemBuffer> results = Wearable.DataApi.getDataItems(mGoogleApiClient);
    results.setResultCallback(new ResultCallback<DataItemBuffer>() {
        @Override
        public void onResult(@NonNull DataItemBuffer dataItems) {
            for (DataItem dataItem : dataItems) {
                switch (Message.getMessageType(dataItem)) {
                    case ACTION_TYPE:
                        int productAction = Message.decodeActionTypeMessage(dataItem);
                        onActionTypeChanged(productAction);
                        break;
                    case INTERACTION_TYPE:
                        int interactionType = Message.decodeInteractionTypeMessage(dataItem);
                        onInteractionTypeChanged(interactionType);
                        break;
                }
            }
            dataItems.release();
        }
    });
}
 

import com.google.android.gms.wearable.DataItemBuffer; //导入依赖的package包/类
public final PendingResult<DataItemBuffer> getDataItems(GoogleApiClient paramGoogleApiClient, final Uri paramUri, final int paramInt)
{
  if (paramUri != null) {}
  for (boolean bool1 = true;; bool1 = false)
  {
    com.google.android.gms.common.internal.zzx.zzb(bool1, "uri must not be null");
    boolean bool2;
    if (paramInt != 0)
    {
      bool2 = false;
      if (paramInt != 1) {}
    }
    else
    {
      bool2 = true;
    }
    com.google.android.gms.common.internal.zzx.zzb(bool2, "invalid filter type");
    paramGoogleApiClient.zza(new zzi(paramGoogleApiClient) {});
  }
}
 

import com.google.android.gms.wearable.DataItemBuffer; //导入依赖的package包/类
/**
 * Retrieve wear settings from Wear cloud storage
 */
public void updateSettings(Context context) {
    if (!googleApiClient.isConnected()) {
        if (!blockingConnect()) {
            return;
        }
    }

    ArrayList<DataMap> data;
    DataItemBuffer dataItemBuffer = Wearable.DataApi.getDataItems(googleApiClient).await();

    if (dataItemBuffer.getStatus().isSuccess()) {
        for (DataItem dataItem : dataItemBuffer) {
            DataMapItem dataMapItem = DataMapItem.fromDataItem(dataItem);
            data = dataMapItem.getDataMap().getDataMapArrayList(WearableConstants.EXTRA_SETTINGS);
            if (data != null) {
                ListenerService.extractSettings(data);
                break;
            }
        }
    }
    dataItemBuffer.release();
}
 

import com.google.android.gms.wearable.DataItemBuffer; //导入依赖的package包/类
/**
 * This method read the UART configurations from the DataApi and populates the adapter with them.
 */
private void populateConfigurations() {
	if (mGoogleApiClient.isConnected()) {
		final PendingResult<DataItemBuffer> results = Wearable.DataApi.getDataItems(mGoogleApiClient, Uri.parse("wear:" + Constants.UART.CONFIGURATIONS), DataApi.FILTER_PREFIX);
		results.setResultCallback(dataItems -> {
			final List<UartConfiguration> configurations = new ArrayList<>(dataItems.getCount());
			for (int i = 0; i < dataItems.getCount(); ++i) {
				final DataItem item = dataItems.get(i);
				final long id = ContentUris.parseId(item.getUri());
				final DataMap dataMap = DataMapItem.fromDataItem(item).getDataMap();
				final UartConfiguration configuration = new UartConfiguration(dataMap, id);
				configurations.add(configuration);
			}
			mAdapter.setConfigurations(configurations);
			dataItems.release();
		});
	}
}
 

import com.google.android.gms.wearable.DataItemBuffer; //导入依赖的package包/类
public static ArrayList<String> getKeySet(GoogleApiClient apiClient, String path) {
    final DataItemBuffer buffer = Wearable.DataApi.getDataItems(
            apiClient,
            Uri.parse("wear:" + path))
            .await();

    ArrayList<String> keySet = null;
    try {
        if (buffer.getCount() > 0) {
            final DataMap map = DataMap.fromByteArray(buffer.get(0).getData());
            keySet = map.getStringArrayList(KEY_KEY_SET);
        }
    }finally {
        buffer.release();
    }

    return keySet==null?new ArrayList<String>():keySet;
}
 

import com.google.android.gms.wearable.DataItemBuffer; //导入依赖的package包/类
@Override
public void onConnected(Bundle connectionHint) {
  Wearable.DataApi.addListener(googleApiClient, this);

  Wearable.DataApi.getDataItems(googleApiClient).setResultCallback(new ResultCallback<DataItemBuffer>() {
    @Override
    public void onResult(DataItemBuffer dataItems) {
      for (DataItem dataItem : dataItems) {
        String[] parts = dataItem.getUri().getPath().split("/");
        switch (parts[1]) {
          case "image":
            photos.put(parts[2], dataItem);
            break;
          default:
            break;
        }
      }
      invalidate();
    }
  });
}
 

import com.google.android.gms.wearable.DataItemBuffer; //导入依赖的package包/类
@Override
public void onConnected(Bundle bundle) {
  Wearable.DataApi.addListener(googleApiClient, this);

  Wearable.DataApi.getDataItems(googleApiClient).setResultCallback(new ResultCallback<DataItemBuffer>() {
    @Override
    public void onResult(DataItemBuffer dataItems) {
      for (DataItem dataItem : dataItems) {
        String[] parts = dataItem.getUri().getPath().split("/");
        switch (parts[1]) {
          case "image":
            String photoId = parts[2];
            enabledPhotos.add(photoId);
            PhotoListEntry photoListEntry = photosById.get(photoId);
            if (photoListEntry == null)
              continue;
            recyclerAdapter.notifyItemChanged(photoListEntry.getPosition());
            break;
          default:
            break;
        }
      }
    }
  });
}
 

import com.google.android.gms.wearable.DataItemBuffer; //导入依赖的package包/类
protected void reloadVehicleData(String dataType){
    final String dataPath = WearUtils.VEHICLE_DATA_PREFIX + dataType;
    apiClientMgr.addTask(new GoogleApiClientTask() {
        @Override
        protected void doRun() {
            final Uri dataItemUri = new Uri.Builder().scheme(PutDataRequest.WEAR_URI_SCHEME).path(dataPath)
                    .build();

            Wearable.DataApi.getDataItems(getGoogleApiClient(), dataItemUri)
                    .setResultCallback(new ResultCallback<DataItemBuffer>() {
                        @Override
                        public void onResult(DataItemBuffer dataItemBuffer) {
                            final int dataCount = dataItemBuffer.getCount();
                            for(int i = 0; i < dataCount; i++) {
                                final DataItem dataItem = dataItemBuffer.get(i);
                                if (dataItem != null)
                                    onDataItemReceived(dataItem, DataEvent.TYPE_CHANGED);
                            }

                            dataItemBuffer.release();
                        }
                    });
        }
    });
}
 

import com.google.android.gms.wearable.DataItemBuffer; //导入依赖的package包/类
private void updateContextStreamNotification() {
    final String dataPath = WearUtils.VEHICLE_DATA_PREFIX + AttributeType.STATE;
    apiClientMgr.addTask(new GoogleApiClientTask() {
        @Override
        protected void doRun() {
            final Uri dataItemUri = new Uri.Builder().scheme(PutDataRequest.WEAR_URI_SCHEME).path(dataPath).build();

            Wearable.DataApi.getDataItems(getGoogleApiClient(), dataItemUri)
                    .setResultCallback(new ResultCallback<DataItemBuffer>() {
                        @Override
                        public void onResult(DataItemBuffer dataItems) {
                            final int dataCount = dataItems.getCount();
                            for (int i = 0; i < dataCount; i++) {
                                final DataItem dataItem = dataItems.get(i);
                                handleDataItem(dataItem, DataEvent.TYPE_CHANGED);
                            }

                            dataItems.release();
                        }
                    });
        }
    });
}
 

import com.google.android.gms.wearable.DataItemBuffer; //导入依赖的package包/类
public void onDeleteEventsClicked(View v) {
    if (mGoogleApiClient.isConnected()) {
        Wearable.DataApi.getDataItems(mGoogleApiClient)
                .setResultCallback(new ResultCallback<DataItemBuffer>() {
                    @Override
                    public void onResult(DataItemBuffer result) {
                        if (result.getStatus().isSuccess()) {
                            deleteDataItems(result);
                        } else {
                            if (Log.isLoggable(TAG, Log.DEBUG)) {
                                Log.d(TAG, "onDeleteEventsClicked(): failed to get Data Items");
                            }
                        }
                        result.close();
                    }
                });
    } else {
        Log.e(TAG, "Failed to delete data items"
                 + " - Client disconnected from Google Play Services");
    }
}
 

import com.google.android.gms.wearable.DataItemBuffer; //导入依赖的package包/类
public void onDeleteEventsClicked(View view) {
    if (mGoogleApiClient.isConnected()) {
        Wearable.DataApi.getDataItems(mGoogleApiClient)
                .setResultCallback(new ResultCallback<DataItemBuffer>() {
                    @Override
                    public void onResult(DataItemBuffer result) {
                        try {
                            if (result.getStatus().isSuccess()) {
                                deleteDataItems(result);
                            } else {
                                if (Log.isLoggable(TAG, Log.DEBUG)) {
                                    Log.d(TAG, "onDeleteEventsClicked(): failed to get Data "
                                            + "Items");
                                }
                            }
                        } finally {
                            result.release();
                        }
                    }
                });
    } else {
        Log.e(TAG, "Failed to delete data items"
                + " - Client disconnected from Google Play Services");
    }
}