How to delete appdata via Windows Device Portal?

函宁刘 80

11111

Just as the image showing.

函宁刘 80 Reputation points

2023-09-08T05:27:01.3733333+00:00

I 've looked up for some documents and try to delete these files using RESTful API but it still doesn't work.

The link I've reviewed before:
https://learn.microsoft.com/en-us/windows/uwp/debug-test-perf/device-portal-api-core#delete-a-file
Zuocheng Wang - MSFT 3,081 Reputation points Microsoft Vendor

2023-09-08T10:12:53.46+00:00

Hello, Welcome to Microsoft Q&A,

Could you describe how you create these folders? If you can provide relevant code, I will try to reproduce the issue. Could you share with us the contents of these folders?

函宁刘 80

I created these folders by using "air tap" gesture. The application didn't give me any feedback after the "air tap" gesture, but it indeed created new files.
I'm new to c++ and HoloLens development, here is the code of "AppMain.cpp" of the Recorder application:

#include "pch.h"
#include "AppMain.h"

//#define RECORDER_USE_SPEECH

// By default all sensors are enabled. To only enable individual sensors, simply add types from HoloLensForCV::SensorType.
std::vector<HoloLensForCV::SensorType> kEnabledSensorTypes = {};

using namespace Windows::Foundation;
using namespace Windows::Foundation::Numerics;
using namespace Windows::Networking;
using namespace Windows::Networking::Connectivity;
using namespace Windows::Networking::Sockets;
using namespace Windows::Storage::Streams;
using namespace Windows::Graphics::Holographic;
using namespace Windows::Perception::Spatial;
using namespace Windows::UI::Input::Spatial;

namespace Recorder
{
  AppMain::AppMain(const std::shared_ptr<Graphics::DeviceResources>& deviceResources)
    : Holographic::AppMainBase(deviceResources)
    , _speechSynthesizer(ref new Windows::Media::SpeechSynthesis::SpeechSynthesizer())
    , _photoVideoMediaFrameSourceGroupStarted(false)
    , _researchModeMediaFrameSourceGroupStarted(false)
    , _sensorFrameRecorderStarted(false)
  {
  }

  void AppMain::OnHolographicSpaceChanged(
    Windows::Graphics::Holographic::HolographicSpace^ holographicSpace)
  {
    StartHoloLensMediaFrameSourceGroup();

#ifdef RECORDER_USE_SPEECH
    StartRecognizeSpeechCommands();
    Platform::StringReference startSentence =
      L"Say 'start' to begin, and 'stop' to end recording";
#else
    Platform::StringReference startSentence =
      L"Air tap to begin and end recording";
#endif
    SaySentence(startSentence);
  }

  void AppMain::OnSpatialInput(
    _In_ Windows::UI::Input::Spatial::SpatialInteractionSourceState^ pointerState)
  {
#ifndef RECORDER_USE_SPEECH
    if (_sensorFrameRecorderStarted) {
      concurrency::create_async([&]() { StopRecording(); });
    }
    else
    {
      concurrency::create_async([&]() { StartRecording(); });
    }
#endif // RECORDER_USE_SPEECH
  }

  void AppMain::OnUpdate(
    _In_ Windows::Graphics::Holographic::HolographicFrame^ holographicFrame,
    _In_ const Graphics::StepTimer& stepTimer) {
    UNREFERENCED_PARAMETER(holographicFrame);
    UNREFERENCED_PARAMETER(stepTimer);
  }

  void AppMain::LoadAppState()
  {
    StartHoloLensMediaFrameSourceGroup();
  }

  void AppMain::SaveAppState()
  {
    if (_photoVideoMediaFrameSourceGroup == nullptr || _researchModeMediaFrameSourceGroup == nullptr) {
      return;
    }


    concurrency::create_task(_photoVideoMediaFrameSourceGroup->StopAsync()).then([&]()
    {
        concurrency::create_task(_researchModeMediaFrameSourceGroup->StopAsync()).then([&]()
        {
            StopRecording();
            
            delete _photoVideoMediaFrameSourceGroup;
            _photoVideoMediaFrameSourceGroup = nullptr;
            _photoVideoMediaFrameSourceGroupStarted = false;

            delete _researchModeMediaFrameSourceGroup;
            _researchModeMediaFrameSourceGroup = nullptr;
            _researchModeMediaFrameSourceGroupStarted = false;
        }).wait();
    }).wait();
  }

  void AppMain::OnPreRender() {}

  void AppMain::OnRender() {}

  void AppMain::StartRecording()
  {
    std::unique_lock<std::mutex> lock(_startStopRecordingMutex);

    if (!_photoVideoMediaFrameSourceGroupStarted || !_researchModeMediaFrameSourceGroupStarted || _sensorFrameRecorderStarted)
    {
      return;
    }

    SaySentence(Platform::StringReference(L"Beginning recording"));

    auto sensorFrameRecorderStartAsyncTask =
      concurrency::create_task(
        _sensorFrameRecorder->StartAsync());

    sensorFrameRecorderStartAsyncTask.then([&]()
    {
      _sensorFrameRecorderStarted = true;
    });
  }

  void AppMain::StopRecording()
  {
    std::unique_lock<std::mutex> lock(_startStopRecordingMutex);

    if (!_photoVideoMediaFrameSourceGroupStarted || !_researchModeMediaFrameSourceGroupStarted || !_sensorFrameRecorderStarted)
    {
      return;
    }

    SaySentence(Platform::StringReference(L"Ending recording, wait a moment to finish"));

    _sensorFrameRecorder->Stop();
    _sensorFrameRecorderStarted = false;

    SaySentence(Platform::StringReference(L"Finished recording"));
  }

  concurrency::task<void> AppMain::StopCurrentRecognizerIfExists()
  {
    if (_speechRecognizer != nullptr)
    {
      return concurrency::create_task(_speechRecognizer->StopRecognitionAsync()).
        then([this]()
      {
        _speechRecognizer->RecognitionQualityDegrading -=
          _speechRecognitionQualityDegradedToken;

        if (_speechRecognizer->ContinuousRecognitionSession != nullptr)
        {
          _speechRecognizer->ContinuousRecognitionSession->ResultGenerated -=
            _speechRecognizerResultEventToken;
        }
      });
    }
    else
    {
      return concurrency::create_task([this]() {});
    }
  }

  bool AppMain::InitializeSpeechRecognizer()
  {
    _speechRecognizer =
      ref new Windows::Media::SpeechRecognition::SpeechRecognizer();

    if (!_speechRecognizer)
    {
      return false;
    }

    _speechRecognitionQualityDegradedToken = _speechRecognizer->RecognitionQualityDegrading +=
      ref new TypedEventHandler<Windows::Media::SpeechRecognition::SpeechRecognizer^, Windows::Media::SpeechRecognition::SpeechRecognitionQualityDegradingEventArgs^>(
        std::bind(&AppMain::OnSpeechQualityDegraded, this, std::placeholders::_1, std::placeholders::_2)
        );

    _speechRecognizerResultEventToken = _speechRecognizer->ContinuousRecognitionSession->ResultGenerated +=
      ref new TypedEventHandler<Windows::Media::SpeechRecognition::SpeechContinuousRecognitionSession^, Windows::Media::SpeechRecognition::SpeechContinuousRecognitionResultGeneratedEventArgs^>(
        std::bind(&AppMain::OnSpeechResultGenerated, this, std::placeholders::_1, std::placeholders::_2)
        );

    return true;
  }

  concurrency::task<bool> AppMain::StartRecognizeSpeechCommands()
  {
    return StopCurrentRecognizerIfExists().then([this]()
    {
      if (!InitializeSpeechRecognizer())
      {
        return concurrency::task_from_result<bool>(false);
      }

      // Here, we compile the list of voice commands by reading them from the map.
      Platform::Collections::Vector<Platform::String^>^ speechCommandList =
        ref new Platform::Collections::Vector<Platform::String^>();

      speechCommandList->Append(L"start");
      speechCommandList->Append(L"stop");

      Windows::Media::SpeechRecognition::SpeechRecognitionListConstraint^ spConstraint =
        ref new Windows::Media::SpeechRecognition::SpeechRecognitionListConstraint(
          speechCommandList);

      _speechRecognizer->Constraints->Clear();
      _speechRecognizer->Constraints->Append(spConstraint);

      return concurrency::create_task(
        _speechRecognizer->CompileConstraintsAsync()).
        then([this](concurrency::task<Windows::Media::SpeechRecognition::SpeechRecognitionCompilationResult^> previousTask)
      {
        try
        {
          Windows::Media::SpeechRecognition::SpeechRecognitionCompilationResult^ compilationResult =
            previousTask.get();

          if (compilationResult->Status == Windows::Media::SpeechRecognition::SpeechRecognitionResultStatus::Success)
          {
            // If compilation succeeds, we can start listening for results.
            return concurrency::create_task(
              _speechRecognizer->ContinuousRecognitionSession->StartAsync()).
              then([this](concurrency::task<void> startAsyncTask)
            {
              try
              {
                // StartAsync may throw an exception if your app doesn't have Microphone permissions. 
                // Make sure they're caught and handled appropriately (otherwise the app may silently not work as expected)
                startAsyncTask.get();
                return true;
              }
              catch (Platform::Exception^ exception)
              {
                dbg::trace(
                  L"Exception while trying to start speech recognition: %s",
                  exception->Message->Data());

                return false;
              }
            });
          }
          else
          {
            dbg::trace(
              L"Could not initialize constraint-based speech engine!");

            // Handle errors here.
            return concurrency::create_task([this] { return false; });
          }
        }
        catch (Platform::Exception^ exception)
        {
          // Note that if you get an "Access is denied" exception, you might need to enable the microphone 
          // privacy setting on the device and/or add the microphone capability to your app manifest.

          dbg::trace(
            L"Exception while trying to initialize speech command list: %s",
            exception->Message->Data());

          // Handle exceptions here.
          return concurrency::create_task([this] { return false; });
        }
      });
    });
  }

  void AppMain::SaySentence(Platform::StringReference sentence)
  {
    concurrency::create_task(
      _speechSynthesizer->SynthesizeTextToStreamAsync(sentence),
      concurrency::task_continuation_context::use_current()).
      then([this](
        concurrency::task<Windows::Media::SpeechSynthesis::SpeechSynthesisStream^> synthesisStreamTask)
    {
      try
      {
        auto stream =
          synthesisStreamTask.get();

        auto hr =
          _speechSynthesisSound.Initialize(
            stream,
            0 /* loopCount */);

        if (SUCCEEDED(hr))
        {
          _speechSynthesisSound.SetEnvironment(HrtfEnvironment::Small);
          _speechSynthesisSound.Start();
        }
      }
      catch (Platform::Exception^ exception)
      {
        dbg::trace(
          L"Exception while trying to synthesize speech: %s",
          exception->Message->Data());
      }
    });
  }

  void AppMain::OnSpeechResultGenerated(
    Windows::Media::SpeechRecognition::SpeechContinuousRecognitionSession ^sender,
    Windows::Media::SpeechRecognition::SpeechContinuousRecognitionResultGeneratedEventArgs ^args)
  {
    // For our list of commands, medium confidence is good enough. 
    // We also accept results that have high confidence.
    if ((args->Result->Confidence == Windows::Media::SpeechRecognition::SpeechRecognitionConfidence::High) ||
      (args->Result->Confidence == Windows::Media::SpeechRecognition::SpeechRecognitionConfidence::Medium))
    {
      if (args->Result->Text == L"start")
      {
        concurrency::create_async([&]() { StartRecording(); });
      }
      else if (args->Result->Text == L"stop")
      {
        concurrency::create_async([&]() { StopRecording(); });
      }

      // When the debugger is attached, we can print information to the debug console.
      dbg::trace(
        L"Last voice command was: '%s'",
        args->Result->Text->Data());
    }
    else
    {
      dbg::trace(
        L"Recognition confidence not high enough.");
    }
  }

  void AppMain::OnSpeechQualityDegraded(
    Windows::Media::SpeechRecognition::SpeechRecognizer^ recognizer,
    Windows::Media::SpeechRecognition::SpeechRecognitionQualityDegradingEventArgs^ args)
  {
    switch (args->Problem)
    {
    case Windows::Media::SpeechRecognition::SpeechRecognitionAudioProblem::TooFast:
      dbg::trace(L"The user spoke too quickly.");
      break;

    case Windows::Media::SpeechRecognition::SpeechRecognitionAudioProblem::TooSlow:
      dbg::trace(L"The user spoke too slowly.");
      break;

    case Windows::Media::SpeechRecognition::SpeechRecognitionAudioProblem::TooQuiet:
      dbg::trace(L"The user spoke too softly.");
      break;

    case Windows::Media::SpeechRecognition::SpeechRecognitionAudioProblem::TooLoud:
      dbg::trace(L"The user spoke too loudly.");
      break;

    case Windows::Media::SpeechRecognition::SpeechRecognitionAudioProblem::TooNoisy:
      dbg::trace(L"There is too much noise in the signal.");
      break;

    case Windows::Media::SpeechRecognition::SpeechRecognitionAudioProblem::NoSignal:
      dbg::trace(L"There is no signal.");
      break;

    case Windows::Media::SpeechRecognition::SpeechRecognitionAudioProblem::None:
    default:
      dbg::trace(L"An error was reported with no information.");
      break;
    }
  }

  void AppMain::PlayVoiceCommandRecognitionSound()
  {
    // The user should be given a cue when recognition is complete. 
    auto hr = _voiceCommandRecognitionSound.GetInitializationStatus();
    if (SUCCEEDED(hr))
    {
      // re-initialize the sound so it can be replayed.
      _voiceCommandRecognitionSound.Initialize(
        L"Audio\\BasicResultsEarcon.wav",
        0 /* loopCount */);

      _voiceCommandRecognitionSound.SetEnvironment(
        HrtfEnvironment::Small);

      _voiceCommandRecognitionSound.Start();
    }
  }

  void AppMain::StartHoloLensMediaFrameSourceGroup()
  {
    REQUIRES(
      !_photoVideoMediaFrameSourceGroupStarted &&
      !_researchModeMediaFrameSourceGroupStarted &&
      !_sensorFrameRecorderStarted &&
      nullptr != _spatialPerception);

    _sensorFrameRecorder =
      ref new HoloLensForCV::SensorFrameRecorder();

    _photoVideoMediaFrameSourceGroup =
        ref new HoloLensForCV::MediaFrameSourceGroup(
            HoloLensForCV::MediaFrameSourceGroupType::PhotoVideoCamera,
            _spatialPerception, _sensorFrameRecorder);

    _researchModeMediaFrameSourceGroup =
        ref new HoloLensForCV::MediaFrameSourceGroup(
            HoloLensForCV::MediaFrameSourceGroupType::HoloLensResearchModeSensors,
            _spatialPerception, _sensorFrameRecorder);

    //
    // Enabling all of the Research Mode sensors at the same time can be quite expensive
    // performance-wise. It's best to scope down the list of enabled sensors to just those
    // that are required for a given task. In this example, all sensors are selected.
    // To only select a subset, use the commented code below.
    //


    if (kEnabledSensorTypes.empty())
    {
        _sensorFrameRecorder->EnableAll();
        _photoVideoMediaFrameSourceGroup->EnableAll();
        _researchModeMediaFrameSourceGroup->EnableAll();
    }
    else
    {
        for (const auto enabledSensorType : kEnabledSensorTypes)
        {
            _sensorFrameRecorder->Enable(enabledSensorType);
            if (enabledSensorType == HoloLensForCV::SensorType::PhotoVideo)
            {
                _photoVideoMediaFrameSourceGroup->Enable(enabledSensorType);
            }
            else
            {
                _researchModeMediaFrameSourceGroup->Enable(enabledSensorType);
            }
        }
    }

    //
    // Start the media frame source groups.
    //

    auto startPhotoVideoMediaFrameSourceGroupTask =
        concurrency::create_task(
            _photoVideoMediaFrameSourceGroup->StartAsync());

    startPhotoVideoMediaFrameSourceGroupTask.then([&]() {
        _photoVideoMediaFrameSourceGroupStarted = true;
    });

    auto startReseachModeMediaFrameSourceGroupTask =
        concurrency::create_task(
            _researchModeMediaFrameSourceGroup->StartAsync());

    startReseachModeMediaFrameSourceGroupTask.then([&]() {
        _researchModeMediaFrameSourceGroupStarted = true;
    });
  }
}

函宁刘 80

I extracted some code from the "AppMain.cpp" file:

I think this part means that the app should give me a voice instruction after launching, but I can hear nothing:

  void AppMain::OnHolographicSpaceChanged(
     Windows::Graphics::Holographic::HolographicSpace^ holographicSpace) 
  {     
	 StartHoloLensMediaFrameSourceGroup();  
#ifdef RECORDER_USE_SPEECH
     StartRecognizeSpeechCommands();
     Platform::StringReference startSentence = 
      L"Say 'start' to begin, and 'stop' to end recording"; 
#else 
     Platform::StringReference startSentence = 
      L"Air tap to begin and end recording"; 
#endif 
     SaySentence(startSentence); 
  }

I think this part means that the app should give me a voice feedback after "start recording", but I can hear nothing:

  void AppMain::StartRecording() 
  {     std::unique_lock<std::mutex> lock(_startStopRecordingMutex); 
     if (!_photoVideoMediaFrameSourceGroupStarted || !_researchModeMediaFrameSourceGroupStarted || _sensorFrameRecorderStarted) 
    { 
      return; 
    } 
     SaySentence(Platform::StringReference(L"Beginning recording")); 
     auto sensorFrameRecorderStartAsyncTask = 
      concurrency::create_task( 
        _sensorFrameRecorder->StartAsync()); 

     sensorFrameRecorderStartAsyncTask.then([&]() 
    { 
      _sensorFrameRecorderStarted = true; 
    }); 
  }

Deleted

This comment has been deleted due to a violation of our Code of Conduct. The comment was manually reported or identified through automated detection before action was taken. Please refer to our Code of Conduct for more information.

2 answers

Zuocheng Wang - MSFT 3,081 Reputation points Microsoft Vendor

2023-09-19T10:06:32.84+00:00

Hello, Welcome to Microsoft Q&A,

We tested your code and confirmed with the team that HoloLens 1 does not support manually deleting these subfolders through the Device Portal. You can try to delete them via API - StorageFolder.DeleteAsync Method (Windows.Storage) - Windows UWP applications | Microsoft Learn.

If the response is helpful, please click "Accept Answer" and upvote it.

Note: Please follow the steps in our documentation to enable e-mail notifications if you want to receive the related email notification for this thread.
Please sign in to rate this answer.

2 people found this answer helpful.

0 comments No comments
Sign in to comment
Deleted

This answer has been deleted due to a violation of our Code of Conduct. The answer was manually reported or identified through automated detection before action was taken. Please refer to our Code of Conduct for more information.

Comments have been turned off. Learn more