@Override
        public void onItemClick(AdapterView<?> parent, View view, int position, long id) {
          /*
          Retrieve the place ID the selected item from the Adapter
          Each Place suggestion is stored as an AutocompletePrediction
          in the Adapter
           */

          final AutocompletePrediction item = mPlaceAdapter.getItem(position);
          final String placeId = item.getPlaceId();
          final CharSequence primaryText = item.getPrimaryText(null);

          Log.i(TAG, "Autocomplete item selected: " + primaryText);

          /*
          Issue a request to the Places Geo Data API to retrieve a Place object with
          additional details about the place
           */
          PendingResult<PlaceBuffer> placeResult =
              Places.GeoDataApi.getPlaceById(mGoogleApiClient, placeId);
          placeResult.setResultCallback(mUpdatePlaceDetailsCallback);

          mAutocompleteView.setText(primaryText);

          Log.i(TAG, "Called getPlaceById to get Place details for " + placeId);
        }
  // Called when the Google+ client is connected.
  @Override
  public void onConnected(Bundle bundle) {
    Activity activity = getActivity("onConnected()");
    if (activity == null) {
      return;
    }

    LOGD(TAG, "Helper connected, account " + mAccountName);

    // load user's Google+ profile, if we don't have it yet
    if (!AccountUtils.hasPlusInfo(activity, mAccountName)) {
      LOGD(TAG, "We don't have Google+ info for " + mAccountName + " yet, so loading.");
      PendingResult<People.LoadPeopleResult> result = Plus.PeopleApi.load(mGoogleApiClient, "me");
      result.setResultCallback(this);
    } else {
      LOGD(TAG, "No need for Google+ info, we already have it.");
    }

    // try to authenticate, if we don't have a token yet
    if (!AccountUtils.hasToken(activity, mAccountName)) {
      LOGD(TAG, "We don't have auth token for " + mAccountName + " yet, so getting it.");
      mTokenTask = new GetTokenTask();
      mTokenTask.execute();
    } else {
      LOGD(TAG, "No need for auth token, we already have it.");
      reportAuthSuccess(false);
    }
  }
  /**
   * Submits an autocomplete query to the Places Geo Data Autocomplete API. Results are returned as
   * frozen AutocompletePrediction objects, ready to be cached. objects to store the Place ID and
   * description that the API returns. Returns an empty list if no results were found. Returns null
   * if the API client is not available or the query did not complete successfully. This method MUST
   * be called off the main UI thread, as it will block until data is returned from the API, which
   * may include a network request.
   *
   * @param constraint Autocomplete query string
   * @return Results from the autocomplete API or null if the query was not successful.
   * @see Places#GEO_DATA_API#getAutocomplete(CharSequence)
   * @see AutocompletePrediction#freeze()
   */
  private ArrayList<AutocompletePrediction> getAutocomplete(CharSequence constraint) {
    if (mGoogleApiClient.isConnected()) {
      Log.i(TAG, "Starting autocomplete query for: " + constraint);

      // Submit the query to the autocomplete API and retrieve a PendingResult that will
      // contain the results when the query completes.
      PendingResult<AutocompletePredictionBuffer> results =
          Places.GeoDataApi.getAutocompletePredictions(
              mGoogleApiClient, constraint.toString(), mBounds, mPlaceFilter);

      // This method should have been called off the main UI thread. Block and wait for at most 60s
      // for a result from the API.
      AutocompletePredictionBuffer autocompletePredictions = results.await(60, TimeUnit.SECONDS);

      // Confirm that the query completed successfully, otherwise return null
      final Status status = autocompletePredictions.getStatus();
      if (!status.isSuccess()) {
        Toast.makeText(
                getContext(), "Error contacting API: " + status.toString(), Toast.LENGTH_SHORT)
            .show();
        Log.e(TAG, "Error getting autocomplete prediction API call: " + status.toString());
        autocompletePredictions.release();
        return null;
      }

      Log.i(
          TAG, "Query completed. Received " + autocompletePredictions.getCount() + " predictions.");

      // Freeze the results immutable representation that can be stored safely.
      return DataBufferUtils.freezeAndClose(autocompletePredictions);
    }
    Log.e(TAG, "Google API client is not connected for autocomplete query.");
    return null;
  }
  @Override
  protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_main22);
    ed = (EditText) findViewById(R.id.editText2);
    Toolbar toolbar = (Toolbar) findViewById(R.id.toolbar);
    setSupportActionBar(toolbar);
    googleApiClient = MainActivity.getGoogleApiClient();
    FloatingActionButton fab = (FloatingActionButton) findViewById(R.id.fab);
    id = DriveId.decodeFromString(getIntent().getExtras().getString("id"));
    text = "";
    final DriveFile df = id.asDriveFile();
    final Lectura llig = new Lectura();

    llig.execute(df);

    while (!isReaded) {
      if (text == "") {

      } else {
        ed.setText(text);
        isReaded = true;
      }
    }
    final Escritura escriu = new Escritura();

    fab.setOnClickListener(
        new View.OnClickListener() {
          @Override
          public void onClick(View v) {
            Toast.makeText(getApplicationContext(), "Actualitzant...", Toast.LENGTH_SHORT).show();
            escriu.setText(ed.getText().toString());

            escriu.execute(df);

            Toast.makeText(getApplicationContext(), "Actualitzat!", Toast.LENGTH_SHORT).show();
            finishActivity(RESULT_OK);
          }
        });

    ResultCallback<DriveApi.DriveContentsResult> contentsOpenedCallback =
        new ResultCallback<DriveApi.DriveContentsResult>() {
          @Override
          public void onResult(DriveApi.DriveContentsResult result) {
            if (!result.getStatus().isSuccess()) {

              // display an error saying file can't be opened
              return;
            }
            // DriveContents object contains pointers
            // to the actual byte stream
            DriveContents contents = result.getDriveContents();
          }
        };

    PendingResult<DriveApi.DriveContentsResult> opened =
        df.open(googleApiClient, DriveFile.MODE_READ_WRITE, null);
    opened.setResultCallback(contentsOpenedCallback);
  }
  /**
   * Adds DataItem to the Android Wear network. The updated item is synchronized across all devices.
   *
   * @param dataPath The path to the data
   * @param data The data to send
   * @param callBack The callback to receive the response
   * @param isAsynchronous send data asynchronously
   * @param sendImmediately source :
   *     http://android-developers.blogspot.in/2015/11/whats-new-in-google-play-services-83.html
   *     With Google Play services 8.3, we’ve updated the DataApi to allow for urgency in how data
   *     items are synced. Now, a priority can be added to the data item to determine when it should
   *     be synced. For example, if you are building an app that requires immediate syncing, such as
   *     a remote control app, it can still be done immediately by calling setUrgent(), but for
   *     something such as updating your contacts, you could tolerate some delay. Non-urgent
   *     DataItems may be delayed for up to 30 minutes, but you can expect that in most cases they
   *     will be delivered within a few minutes. Low priority is now the default, so setUrgent() is
   *     needed to obtain the previous timing.
   */
  public void sendData(
      String dataPath,
      DataMap data,
      ResultCallback<DataApi.DataItemResult> callBack,
      boolean isAsynchronous,
      boolean sendImmediately) {
    if (!isConnected()) {
      if (mConnectionCallBacks != null) {
        mConnectionCallBacks.onConnectionFailed(WearConnectionCallBacks.NETWORK_ERROR);
      }
      return;
    } else if (dataPath == null) {
      if (mConnectionCallBacks != null) {
        mConnectionCallBacks.onConnectionFailed(WearConnectionCallBacks.PATH_NULL_ERROR);
      }
      return;
    } else if (data == null) {
      Log.d("Send DataMap", "Data cannot be null");
      return;
    }

    PutDataMapRequest putDataMapRequest = PutDataMapRequest.create(dataPath);
    putDataMapRequest.getDataMap().putAll(data);

    /** Current time is also sent with data, just to make it a new data */
    putDataMapRequest
        .getDataMap()
        .putString(
            WearConnectionConstants.KEY.CURRENT_TIME, String.valueOf(System.currentTimeMillis()));

    PutDataRequest request = putDataMapRequest.asPutDataRequest();

    // update from google play service 8.3. refer comments above
    if (sendImmediately) {
      request.setUrgent();
    }

    if (isAsynchronous) {
      /** You will get callback after data is sent use the below code */
      PendingResult<DataApi.DataItemResult> dataResult =
          Wearable.DataApi.putDataItem(mGoogleApiClient, request);
      if (callBack != null) {
        dataResult.setResultCallback(callBack);
      }
    } else {
      if (isRunningOnMainThread()) {
        if (mConnectionCallBacks != null) {
          mConnectionCallBacks.onConnectionFailed(
              WearConnectionCallBacks.METHOD_CALLED_FROM_UI_THREAD);
        }
        return;
      }
      Wearable.DataApi.putDataItem(mGoogleApiClient, request).await();
    }
  }
  private ArrayList<PlaceAutocomplete> getAutocomplete(CharSequence constraint) {
    if (mGoogleApiClient.isConnected()) {
      Log.i(TAG, "Starting autocomplete query for: " + constraint);

      // Submit the query to the autocomplete API and retrieve a PendingResult that will
      // contain the results when the query completes.
      PendingResult<AutocompletePredictionBuffer> results =
          Places.GeoDataApi.getAutocompletePredictions(
              mGoogleApiClient, constraint.toString(), null, mPlaceFilter);

      // This method should have been called off the main UI thread. Block and wait for at most 60s
      // for a result from the API.
      AutocompletePredictionBuffer autocompletePredictions = results.await(60, TimeUnit.SECONDS);

      // Confirm that the query completed successfully, otherwise return null
      final Status status = autocompletePredictions.getStatus();
      if (!status.isSuccess()) {
        Toast.makeText(
                getContext(),
                "Error contacting Google Places: " + status.toString(),
                Toast.LENGTH_SHORT)
            .show();
        Log.e(
            TAG,
            "Error getting autocomplete prediction API call: "
                + status.getStatusMessage()
                + status.getStatus().getStatusMessage());
        autocompletePredictions.release();
        return null;
      }

      Log.i(
          TAG, "Query completed. Received " + autocompletePredictions.getCount() + " predictions.");

      // Copy the results into our own data structure, because we can't hold onto the buffer.
      // AutocompletePrediction objects encapsulate the API response (place ID and description).

      Iterator<AutocompletePrediction> iterator = autocompletePredictions.iterator();
      ArrayList resultList = new ArrayList<>(autocompletePredictions.getCount());
      while (iterator.hasNext()) {
        AutocompletePrediction prediction = iterator.next();
        // Get the details of this prediction and copy it into a new PlaceAutocomplete object.
        resultList.add(new PlaceAutocomplete(prediction.getPlaceId(), prediction.getDescription()));
      }

      // Release the buffer now that all data has been copied.
      autocompletePredictions.release();

      return resultList;
    }
    Log.e(TAG, "Google API client is not connected for autocomplete query.");
    return null;
  }
    private void getTotalDistance() {

      Log.d(TAG, "getTotalDistance()");

      if ((mGoogleApiClient != null) && (mGoogleApiClient.isConnected()) && (!mDistanceRequested)) {

        mDistanceRequested = true;

        PendingResult<DailyTotalResult> distanceResult =
            Fitness.HistoryApi.readDailyTotal(mGoogleApiClient, DataType.TYPE_DISTANCE_DELTA);

        distanceResult.setResultCallback(this);
      }
    }
        @Override
        public void onItemClick(AdapterView<?> parent, View view, int position, long id) {
          /*
          Retrieve the place ID of the selected item from the Adapter.
          The adapter stores each Place suggestion in a PlaceAutocomplete object from which we
          read the place ID.
          */
          final PlaceAutocompleteAdapter.PlaceAutocomplete item = mAdapter.getItem(position);
          final String placeId = String.valueOf(item.placeId);
          Log.i(TAG, "Autocomplete item selected: " + item.description);

          PendingResult<PlaceBuffer> placeResult =
              Places.GeoDataApi.getPlaceById(mGoogleApiClient, placeId);

          placeResult.setResultCallback(mPlacePickedChangeMap);
        }
  /*データの種類
  key	     type    備考        format(BluetoothSPP)
  --------------------------------------------------
  scene    string  シーン情報   "scene:ex"
  ready    boolean 準備完了状態 "ready:ex"
  vibrator integer バイブ時間   "vibrator:ex(ms)"
  */
  public void SyncData(
      String key_name, String sync_data) { // HandheldとWear間の各種データの更新をする。データの種類は上記のコメントを参照
    PutDataMapRequest dataMapRequest = PutDataMapRequest.create(globalv.DATA_PATH);
    DataMap dataMap = dataMapRequest.getDataMap();
    // Data set
    dataMap.putString(key_name, sync_data); // ("keyname",data);

    // Data Push
    PutDataRequest request = dataMapRequest.asPutDataRequest();
    PendingResult<DataApi.DataItemResult> pendingResult =
        Wearable.DataApi.putDataItem(mGoogleApiClient, request);
    pendingResult.setResultCallback(
        new ResultCallback<DataApi.DataItemResult>() {
          @Override
          public void onResult(DataApi.DataItemResult dataItemResult) {
            Log.d("TAG", "onResult:" + dataItemResult.getStatus().toString());
          }
        });
  }
Beispiel #10
0
        @Override
        public void onItemClick(AdapterView<?> parent, View view, int position, long id) {
          /*
          Retrieve the place ID of the selected item from the Adapter.
          The adapter stores each Place suggestion in a PlaceAutocomplete object from which we
          read the place ID.
           */
          final PlaceAutocompleteAdapter.PlaceAutocomplete item = mAdapter.getItem(position);
          final String placeId = String.valueOf(item.placeId);
          Log.i("Input place", "Autocomplete item selected: " + item.description);

          /*
          Issue a request to the Places Geo Data API to retrieve a Place object with additional
           details about the place.
           */
          PendingResult<PlaceBuffer> placeResult =
              Places.GeoDataApi.getPlaceById(mGoogleApiClient, placeId);
          placeResult.setResultCallback(mUpdatePlaceDetailsCallback);
          Log.i("Input place", "Called getPlaceById to get Place details for " + item.placeId);
        }
Beispiel #11
0
  public void getRequestedLocations(String query) {
    mQueryLocationRequested = true;
    mRequest = query;
    Log.i(LOG_TAG, "Define query places");
    final PendingResult<AutocompletePredictionBuffer> predictions =
        Places.GeoDataApi.getAutocompletePredictions(mApiClient, query, null, null);
    predictions.setResultCallback(
        new ResultCallback<AutocompletePredictionBuffer>() {
          @Override
          public void onResult(AutocompletePredictionBuffer autocompletePredictions) {
            boolean resultSuccess = autocompletePredictions.getStatus().isSuccess();
            Log.i(LOG_TAG, "Requested places result success: " + resultSuccess);
            if (resultSuccess) {
              mPlacesList.clear();

              List<String> placesIdList = new ArrayList<>();
              for (AutocompletePrediction prediction : autocompletePredictions) {
                Log.d(LOG_TAG, "Place: " + prediction.toString());
                placesIdList.add(prediction.getPlaceId());
              }
              String[] placesIdArray = new String[placesIdList.size()];
              PendingResult<PlaceBuffer> place =
                  Places.GeoDataApi.getPlaceById(mApiClient, placesIdList.toArray(placesIdArray));
              ResultCallback<PlaceBuffer> callback =
                  new ResultCallback<PlaceBuffer>() {
                    @Override
                    public void onResult(PlaceBuffer places) {
                      for (Place place : places) {
                        addPlaceData(place);
                      }
                      ((OnDataReceivedListener) getActivity()).onDataReceived(mPlacesList);
                    }
                  };
              place.setResultCallback(callback);
            }
            mQueryLocationRequested = false;
            mRequest = null;
            autocompletePredictions.release();
          }
        });
  }
 private void save(
     final FormTemplate formToSave,
     final GoogleApiClient googleClient,
     final DriveId dirDriveId,
     final String fileName) {
   PendingResult<DriveApi.DriveContentsResult> driveContentsResults =
       Drive.DriveApi.newDriveContents(googleClient);
   driveContentsResults.setResultCallback(
       new ResultCallback<DriveApi.DriveContentsResult>() {
         public void onResult(DriveApi.DriveContentsResult result) {
           DriveFolder ptFolder = Drive.DriveApi.getFolder(googleClient, dirDriveId);
           DriveContents driveContents = result.getDriveContents();
           Persister persister = new Persister();
           try {
             persister.write(formToSave, driveContents.getOutputStream());
           } catch (Exception ex) {
             Log.e(MainActivity.PT_APP_INFO, "Cannot save for to google drive because " + ex);
           }
           MetadataChangeSet.Builder builder = new MetadataChangeSet.Builder();
           builder.setTitle(fileName);
           ptFolder.createFile(googleClient, builder.build(), driveContents);
         }
       });
 }
  /**
   * Intents come in when the service is started & through the broadcast receiver. This processes
   * them just the same, setting up warning booleans and managing the countdown timer.
   *
   * @param intent The intent to process
   */
  private void processIntent(Intent intent) {
    /* If the intent is null, don't bother */
    if (intent == null) {
      return;
    }

    Bundle extras = intent.getExtras();

    /* If keys exist, process them */
    if (extras.containsKey(FamiliarConstants.KEY_FIVE_MINUTE_WARNING)) {
      mFiveMinuteWarning = extras.getBoolean(FamiliarConstants.KEY_FIVE_MINUTE_WARNING);
    }
    if (extras.containsKey(FamiliarConstants.KEY_TEN_MINUTE_WARNING)) {
      mTenMinuteWarning = extras.getBoolean(FamiliarConstants.KEY_TEN_MINUTE_WARNING);
    }
    if (extras.containsKey(FamiliarConstants.KEY_FIFTEEN_MINUTE_WARNING)) {
      mFifteenMinuteWarning = extras.getBoolean(FamiliarConstants.KEY_FIFTEEN_MINUTE_WARNING);
    }
    if (extras.containsKey(FamiliarConstants.KEY_END_TIME)) {

      /* Stop any current countdowns and remove the notification */
      if (mCountDownTimer != null) {
        mCountDownTimer.cancel();
      }
      mNotificationManager.cancel(NOTIFICATION_ID);

      long endTime = extras.getLong(FamiliarConstants.KEY_END_TIME);
      if (endTime == FamiliarConstants.CANCEL_FROM_MOBILE
          || endTime == FamiliarConstants.CANCEL_FROM_WEAR) {
        /* an end time of 0 means kill the notification */
        unregisterReceiver(mBroadcastReceiver);
        CountdownService.this.stopSelfResult(mStartId);
        /* And tell the app in case this was canceled on the app */
        if (endTime == FamiliarConstants.CANCEL_FROM_WEAR) {
          Log.v("MTG", "cancel button");
          /* This came from the cancel button, so tell the mobile */
          if (mGoogleApiClient.isConnected()) {
            PutDataMapRequest putDataMapReq = PutDataMapRequest.create(FamiliarConstants.PATH);
            putDataMapReq
                .getDataMap()
                .putLong(FamiliarConstants.KEY_END_TIME, FamiliarConstants.CANCEL_FROM_WEAR);
            PutDataRequest putDataReq = putDataMapReq.asPutDataRequest();
            PendingResult<DataApi.DataItemResult> pendingResult =
                Wearable.DataApi.putDataItem(mGoogleApiClient, putDataReq);
            pendingResult.setResultCallback(
                new ResultCallback<DataApi.DataItemResult>() {
                  @Override
                  public void onResult(DataApi.DataItemResult dataItemResult) {
                    Log.v("MTG", "onResult: " + dataItemResult.getStatus().getStatusMessage());
                  }
                });

            Log.v("MTG", "message sent");
          }
        }
      } else {
        /* Display the notification */
        mNotificationManager.notify(NOTIFICATION_ID, mNotificationBuilder.build());

        /* Figure out how far we are away from the end time.
         * Assume mobile and wear clocks are in sync */
        long millisInFuture = endTime - System.currentTimeMillis();
        mCountDownTimer =
            new CountDownTimer(millisInFuture, 1000) {
              /**
               * This should tick once every second. It updates the notification
               *
               * @param millisUntilFinished The time until the countdown finishes
               */
              @Override
              public void onTick(long millisUntilFinished) {

                /* Build the string */
                long secondsLeft = (millisUntilFinished / 1000) % 60;
                long minutesLeft = (millisUntilFinished / (1000 * 60)) % 60;
                long hoursLeft = (millisUntilFinished / (1000 * 60 * 60));
                String messageText =
                    String.format("%02d:%02d:%02d", hoursLeft, minutesLeft, secondsLeft);

                /* Because the ID remains unchanged,
                 * the existing notification is updated. */
                mNotificationBuilder.setContentTitle(messageText);
                mNotificationManager.notify(NOTIFICATION_ID, mNotificationBuilder.build());

                /* Vibrate a pattern if the warnings are set up */
                if (mFifteenMinuteWarning
                    && hoursLeft == 0
                    && minutesLeft == 15
                    && secondsLeft == 0) {
                  /* Buzz */
                  mVibrator.vibrate(200);
                  mFifteenMinuteWarning = false;
                } else if (mTenMinuteWarning
                    && hoursLeft == 0
                    && minutesLeft == 10
                    && secondsLeft == 0) {
                  /* Buzz Buzz */
                  mVibrator.vibrate(new long[] {0, 200, 200, 200}, -1);
                  mTenMinuteWarning = false;
                } else if (mFiveMinuteWarning
                    && hoursLeft == 0
                    && minutesLeft == 5
                    && secondsLeft == 0) {
                  /* Buzz Buzz Buzz*/
                  mVibrator.vibrate(new long[] {0, 200, 200, 200, 200, 200}, -1);
                  mFiveMinuteWarning = false;
                }
              }

              /**
               * The countdown finished. Give one good vibration, remove the notification, clean up
               * the service, and call it a day.
               */
              @Override
              public void onFinish() {
                /* BUZZ */
                mVibrator.vibrate(600);
                /* Cleanup */
                mNotificationManager.cancel(NOTIFICATION_ID);
                unregisterReceiver(mBroadcastReceiver);
                CountdownService.this.stopSelfResult(mStartId);
              }
            };

        /* Start the countdown */
        mCountDownTimer.start();
      }
    }
  }