Java DataType类代码示例

import com.google.android.gms.fitness.data.DataType; //导入依赖的package包/类
@Override
protected Void doInBackground(Void... params) {

    DataDeleteRequest request = new DataDeleteRequest.Builder()
            .setTimeInterval(startTime, endTime, TimeUnit.MILLISECONDS)
            .addDataType(DataType.TYPE_WEIGHT)
            .build();

    com.google.android.gms.common.api.Status insertStatus =
            Fitness.HistoryApi.deleteData(googleFitManager.getGoogleApiClient(), request)
                    .await(1, TimeUnit.MINUTES);

    if (insertStatus.isSuccess()) {
        Log.w("myLog", "+Successfully deleted data.");
    } else {
        Log.w("myLog", "+Failed to delete data.");
    }

    return null;
}
 

import com.google.android.gms.fitness.data.DataType; //导入依赖的package包/类
/**
 * This method creates a dataset object to be able to insert data in google fit
 * @param dataType DataType Fitness Data Type object
 * @param dataSourceType int Data Source Id. For example, DataSource.TYPE_RAW
 * @param value Object Values for the fitness data. They must be int or float
 * @param startTime long Time when the fitness activity started
 * @param endTime long Time when the fitness activity finished
 * @param timeUnit TimeUnit Time unit in which period is expressed
 * @return
 */
private DataSet createDataForRequest(DataType dataType, int dataSourceType, Double value,
                                     long startTime, long endTime, TimeUnit timeUnit) {
    DataSource dataSource = new DataSource.Builder()
            .setAppPackageName(GoogleFitPackage.PACKAGE_NAME)
            .setDataType(dataType)
            .setType(dataSourceType)
            .build();

    DataSet dataSet = DataSet.create(dataSource);
    DataPoint dataPoint = dataSet.createDataPoint().setTimeInterval(startTime, endTime, timeUnit);

    float f1 = Float.valueOf(value.toString());
    dataPoint = dataPoint.setFloatValues(f1);

    dataSet.add(dataPoint);

    return dataSet;
}
 

import com.google.android.gms.fitness.data.DataType; //导入依赖的package包/类
public void findFitnessDataSources() {

        DataSourcesRequest dataSourceRequest = new DataSourcesRequest.Builder()
                .setDataTypes(DataType.TYPE_STEP_COUNT_DELTA, DataType.TYPE_STEP_COUNT_CUMULATIVE)
                .setDataSourceTypes( DataSource.TYPE_DERIVED)
                .build();

        ResultCallback<DataSourcesResult> dataSourcesResultCallback = new ResultCallback<DataSourcesResult>() {
            @Override
            public void onResult(DataSourcesResult dataSourcesResult) {
                for (DataSource dataSource : dataSourcesResult.getDataSources()) {
                    DataType type = dataSource.getDataType();

                    if (DataType.TYPE_STEP_COUNT_DELTA.equals(type)
                            || DataType.TYPE_STEP_COUNT_CUMULATIVE.equals(type)) {
                        Log.i(TAG, "Register Fitness Listener: " + type);
                        registerFitnessDataListener(dataSource, type);//DataType.TYPE_STEP_COUNT_DELTA);
                    }
                }
            }
        };

        Fitness.SensorsApi.findDataSources(googleFitManager.getGoogleApiClient(), dataSourceRequest)
                .setResultCallback(dataSourcesResultCallback);
    }
 

import com.google.android.gms.fitness.data.DataType; //导入依赖的package包/类
private void registerFitnessDataListener(DataSource dataSource, DataType dataType) {

        SensorRequest request = new SensorRequest.Builder()
                .setDataSource(dataSource)
                .setDataType(dataType)
                .setSamplingRate(3, TimeUnit.SECONDS)
                .build();

        Fitness.SensorsApi.add(googleFitManager.getGoogleApiClient(), request, this)
                .setResultCallback(new ResultCallback<Status>() {
                    @Override
                    public void onResult(Status status) {
                        if (status.isSuccess()) {
                            Log.i(TAG, "SensorApi successfully added");
                        }
                    }
                });
    }
 

import com.google.android.gms.fitness.data.DataType; //导入依赖的package包/类
@Override
public void onDataPoint(DataPoint dataPoint) {
    DataType type = dataPoint.getDataType();
    Log.i(TAG, "Detected DataPoint type: " + type);

    for (final Field field : type.getFields()) {
        final Value value = dataPoint.getValue(field);
        Log.i(TAG, "Detected DataPoint field: " + field.getName());
        Log.i(TAG, "Detected DataPoint value: " + value);


   /*     activity.runOnUiThread(new Runnable() {
            @Override
            public void run() {
                Toast.makeText(mReactContext.getApplicationContext(), "Field: " + field.getName() + " Value: " + value, Toast.LENGTH_SHORT).show();
            }
        });*/

        if(type.equals(DataType.TYPE_STEP_COUNT_CUMULATIVE)) {
            WritableMap map = Arguments.createMap();
            map.putDouble("steps", value.asInt());
            sendEvent(this.mReactContext, "StepChangedEvent", map);
        }

    }
}
 

import com.google.android.gms.fitness.data.DataType; //导入依赖的package包/类
@NonNull
@RequiresPermission("android.permission.BLUETOOTH_ADMIN")
public Observable<BleDevice> startBleScan(List<DataType> dataTypes, int timeoutSecs) {
    return ObservableTask.create(callback -> {
        BleScanCallback bleCallBack = new BleScanCallback() {
            @Override
            public void onDeviceFound(BleDevice bleDevice) {
                callback.onNext(bleDevice);
            }

            @Override
            public void onScanStopped() {
                callback.onComplete();
            }
        };
        callback.setDisposeListener(() -> client.stopBleScan(bleCallBack));
        return client.startBleScan(dataTypes, timeoutSecs, bleCallBack);
    });
}
 

import com.google.android.gms.fitness.data.DataType; //导入依赖的package包/类
/**
 * Subscribe to an available {@link DataType}. Subscriptions can exist across application
 * instances (so data is recorded even after the application closes down).  When creating
 * a new subscription, it may already exist from a previous invocation of this app.  If
 * the subscription already exists, the method is a no-op.  However, you can check this with
 * a special success code.
 */
private void subscribeToSteps() {
    Fitness.RecordingApi.subscribe(googleApiClient, DataType.TYPE_STEP_COUNT_DELTA)
            .setResultCallback(new ResultCallback<Status>() {
                @Override
                public void onResult(@NonNull Status status) {
                    if (status.isSuccess()) {
                        if (status.getStatusCode()
                                == FitnessStatusCodes.SUCCESS_ALREADY_SUBSCRIBED) {
                            Log.i(TAG, "Existing subscription for activity detected.");
                        } else {
                            Log.i(TAG, "Successfully subscribed!");
                        }
                    } else {
                        Log.i(TAG, "There was a problem subscribing.");
                    }
                }
            });
}
 

import com.google.android.gms.fitness.data.DataType; //导入依赖的package包/类
/**
 * Cancel the ACTIVITY_SAMPLE subscription by calling unsubscribe on that {@link DataType}.
 */
private void unsubscribeFromSteps() {
    final String dataTypeStr = DataType.TYPE_STEP_COUNT_DELTA.toString();
    Log.i(TAG, "Unsubscribing from data type: " + dataTypeStr);

    // Invoke the Recording API to unsubscribe from the data type and specify a callback that
    // will check the result.
    Fitness.RecordingApi.unsubscribe(googleApiClient, DataType.TYPE_ACTIVITY_SAMPLE)
            .setResultCallback(new ResultCallback<Status>() {
                @Override
                public void onResult(@NonNull Status status) {
                    if (status.isSuccess()) {
                        Log.i(TAG, "Successfully unsubscribed for data type: " + dataTypeStr);
                    } else {
                        // Subscription not removed
                        Log.i(TAG, "Failed to unsubscribe for data type: " + dataTypeStr);
                    }
                }
            });
}
 

import com.google.android.gms.fitness.data.DataType; //导入依赖的package包/类
public void removeSubscription(DataType mDataType) {

        Fitness.RecordingApi.unsubscribe(mClient, mDataType)
                .setResultCallback(new ResultCallback<Status>() {
                    @Override
                    public void onResult(Status status) {
                        if (status.isSuccess()) {
                            runOnUiThread(new Runnable() {
                                @Override
                                public void run() {
                                    mDataTypeList.remove(lastRemovedPosition);
                                    mListAdapter.notifyDataSetChanged();
                                }
                            });
                        } else {
                            Log.i(TAG, "Failed to unsubscribe ");
                        }
                    }
                });
    }
 

import com.google.android.gms.fitness.data.DataType; //导入依赖的package包/类
public void listDataSources(DataType mDataType)
{
    Fitness.SensorsApi.findDataSources(mClient, new DataSourcesRequest.Builder()
            .setDataTypes(mDataType)
            .setDataSourceTypes(DataSource.TYPE_DERIVED)
            .setDataSourceTypes(DataSource.TYPE_RAW)
            .build())
            .setResultCallback(new ResultCallback<DataSourcesResult>() {
                @Override
                public void onResult(DataSourcesResult dataSourcesResult) {
                    mListAdapter.notifyDataSetChanged();
                    if (dataSourcesResult.getDataSources().size() > 0) {
                        mDataSourceList.addAll(dataSourcesResult.getDataSources());
                        mLiveDataText.setText("Please select from following data source to get the live data");
                    } else {
                        mLiveDataText.setText("No data source found for selected data type");
                    }
                }
            });
}
 

import com.google.android.gms.fitness.data.DataType; //导入依赖的package包/类
/**
 * Query to get the num of steps since 00:00 until now
 */
private DataReadRequest queryFitnessData() {
	Calendar cal = Calendar.getInstance();
	Date now = new Date();
	cal.setTime(now);
	long endTime = cal.getTimeInMillis();
	cal.set(Calendar.HOUR_OF_DAY, 0);
	cal.set(Calendar.MINUTE, 0);
	cal.set(Calendar.SECOND, 0);
	cal.set(Calendar.MILLISECOND, 0);
	long startTime = cal.getTimeInMillis();

	return new DataReadRequest.Builder()
			.aggregate(DataType.TYPE_STEP_COUNT_DELTA, DataType.AGGREGATE_STEP_COUNT_DELTA)
			.bucketByTime(1, TimeUnit.DAYS)
			.setTimeRange(startTime, endTime, TimeUnit.MILLISECONDS)
			.build();
}
 

import com.google.android.gms.fitness.data.DataType; //导入依赖的package包/类
public void subscribe() {
    //connect to the step count.
    Fitness.getRecordingClient(getActivity(), GoogleSignIn.getLastSignedInAccount(getContext()))
        .subscribe(DataType.TYPE_STEP_COUNT_DELTA)
        .addOnSuccessListener(new OnSuccessListener<Void>() {
            @Override
            public void onSuccess(Void aVoid) {
                logthis("Subscribed to the Recording API");
            }
        })
        .addOnFailureListener(new OnFailureListener() {
            @Override
            public void onFailure(@NonNull Exception e) {
                logthis("failed to subscribe to the Recording API");
            }
        });
}
 

import com.google.android.gms.fitness.data.DataType; //导入依赖的package包/类
private Task<DataSet> displayTodayData() {
    Log.i(TAG, "Reading History API results for today of Steps");
    return Fitness.getHistoryClient(getActivity(), GoogleSignIn.getLastSignedInAccount(getContext()))
        .readDailyTotal(DataType.TYPE_STEP_COUNT_DELTA)
        .addOnSuccessListener(new OnSuccessListener<DataSet>() {
            @Override
            public void onSuccess(DataSet dataSet) {
                Log.i(TAG, "Reading History API results for today");
                showDataSet(dataSet);
            }
        })
        .addOnFailureListener(new OnFailureListener() {
            @Override
            public void onFailure(@NonNull Exception e) {
                Log.i(TAG, "Failed to read DailyTotal for Steps.");
            }
        });

}
 

import com.google.android.gms.fitness.data.DataType; //导入依赖的package包/类
public Observable<SessionData> loadSessionData(final GoogleApiClient googleApiClient, final String sessionId) {
	// create read request (only read distance, not location for overview)
	final SessionReadRequest readRequest = createReadRequest()
			.setSessionId(sessionId)
			.build();
	return Observable.defer(new Func0<Observable<SessionData>>() {
		@Override
		public Observable<SessionData> call() {
			SessionReadResult readResult = Fitness.SessionsApi.readSession(googleApiClient, readRequest).await();

			if (readResult.getSessions().isEmpty()) throw new IllegalStateException("error finding session " + sessionId);

			// parse result
			Session session = readResult.getSessions().get(0);
			List<Location> locations = locationsFromDataSet(readResult.getDataSet(session, DataType.TYPE_LOCATION_SAMPLE).get(0));
			Timber.d("found " + locations.size() + " locations");
			return Observable.just(new SessionData(session, locations));
		}
	});
}
 

import com.google.android.gms.fitness.data.DataType; //导入依赖的package包/类
public void subscribe(DataType dataType) {
    Fitness.RecordingApi.subscribe(client, dataType)
            .setResultCallback(new ResultCallback<Status>() {
                @Override
                public void onResult(Status status) {
                    if (status.isSuccess()) {
                        if (status.getStatusCode() == FitnessStatusCodes.SUCCESS_ALREADY_SUBSCRIBED) {
                            display.show("Existing subscription for activity detected.");
                        } else {
                            display.show("Successfully subscribed!");
                        }
                    } else {
                        display.show("There was a problem subscribing.");
                    }
                }
            });
}