poniedziałek, 13 marca 2017

[DSP2017] 5# Holowizja - strzał palcem

Witam ponownie w moich wizjach holograficznych. Na razie kontynuuję zaznajamianie się z platformą HoloLens. Dziś coś napiszę o gestach za pomocą dłoni.

Ze spraw poruszanych w rozdziale trzecim Holograms 101E: Introduction with Emulator oraz Holograms 211: Gesture póki co wybrałem sobie do sprawdzenia kursor z feedbackiem na pojawienie się dłoni oraz obsługę zdarzenia “air tap”. Podnosimy palec, zgłaszamy w ten sposób gotowość. Jeśli potem go opuścimy, to tak jakbyśmy kliknęli, tyle że w powietrzu. W jednej wersji HoloLens jest jeszcze clicker, by go używać zamiast ciągle swojego palca.

Możliwości w obsłudze gestów jest więcej. Można zdarzenie nawigacji wykorzystać do obracania przedmiotu za pomocą palca, czy też w ogóle śledzić dłonie i używać ich do manipulacji. HoloLens może też podpowiadać, kiedy nasze dłonie będą blisko wyjścia poza jego obszar obserwacji.

Za pomocą emulatora można zasymulować pojawienie się dłoni lewej i prawej z podaniem ich położenia:

EmulatorSettings

Naciśnięcie Enter oznacza “air tap”, a jeśli naciśniemy Alt i trzymajac prawy przycisk myszy zaczniemy przesuwać kursor, to nawet zdarzenie nawigacji/przewijania zasymulujemy i obrócimy sobie np. kosmonautę z Holograms 211. 

Holo akademia bazuje na elementach dość wczesnej wersji Holo Toolkit. W przykładzie podanym poniżej wypróbowałem najnowszą wersję toolkita pod kątem kursora i air tap.

Zacznijmy od kursora z feedbackiem. Chodzi o to, by po pojawieniu się dłoni kursor zmienił swoją postać np. na dłoń. Na scenie z sześcianem znanej z HoloVision3 poprzedni kursor zastąpiłem nowym z pliku CursorWithFeedback.prefab (Assets > HoloToolkit > Input > Prefabs > Cursor).

Teraz pora na obsługę “kliknięcia”. W tym celu w katalogu Scripts w Assets utworzyłem nowy skrypt C# o nazwie CubeCommands i przypiąłem do sześcianu. Kod skryptu przedstawia się następująco:

public class CubeCommands : MonoBehaviour, IInputClickHandler
{
    public void OnInputClicked(InputEventData eventData)
    {
        if (!this.GetComponent<Rigidbody>())
        {
            var rigidbody = gameObject.AddComponent<Rigidbody>();
            rigidbody.collisionDetectionMode = CollisionDetectionMode.Continuous;
        }
    }
}

Jak widzimy, zaimplementowałem metodę OnInputClicked z interfejsu IInputClickHandler. Jeśli obiekt nie miał poczucia grawitacji, czyli obiektu Rigidbody, to dodaję mu taki. Sześcian po zajściu takiego zdarzenia powinien spaść w dół (dla zmniejszenia zamieszania z kolorem wyrzuciłem poprzedni skrypt ustawiajacy kolor sześcianu na czerwony po objęciu go wzrokiem).

Odpalam i … nie działa. Szybko na logikę wywnioskowałem, że może potrzeba jakiegoś odniesienia, by sześcian miał na co spaść. I tak do sceny dołożyłem płaszczyznę, czyli obiekt typu Plane (Hierarchy: Create –> 3D Object –> Plane). Ustawiłem to nieco, by lepiej wyglądało w kamerze, sześcian też poprawiłem. Dla lepszego nastroju zmieniłem sobie światło na kolor niebieski. Dokładne ustawienia można odczytać sobie w Unity z tego projektu, pobierając go z gałęzi HoloVision4 na github.

Eksportuję once again do Visual Studio. Odpalam:

Schot1

Jak w ustawieniach emulatora pokażę lewą dłoń, to kursor zmieni się w dłoń. Taką postać też przyjmie podczas “klikania palcem”. Naciskam Enter i buch, szescian leci w dół!

Schot2

Hurra! 

Zamierzałem się jeszcze pobawić obracaniem sześcianu przy pomocy nowego Holo Toolkit, ale w jego plikach testowych i komponentach nie widzę dobrego przykładu na obsługę zdarzenia nawigacji/scrollowania. Ludzie pytają o to na forach, więc jest coś na rzeczy. Zawsze mogę użyć elementów bazujących na starszym toolkicie z akademii HoloLens, ale może znajdę działające rozwiązanie przy pomocy najnowszego API. Zobaczymy. Jak znajdę, na pewno o tym napiszę. A tymczasem do zobaczenia w następnym odcinku.

niedziela, 12 marca 2017

[DSP2017] 4# Holowizja - co się gapisz? uważaj, to coś znaczy

Jak komunikować się z hologramem w HoloLens? Jest kilka sposobów, wśród których można wymienić spojrzenie. I o nim dziś będzie mowa.

W  Holographic Academy znajdziemy o tym dwa tutoriale:  Holograms 101E: Introduction with Emulator i Holograms 210: Gaze. Pierwszy zawiera prosty przykład w rozdziale 2. Drugi tutorial we wszystkich swoich 6 częściach pokazuje bardziej zaawansowane przykłady. Jednak do jego rodziału trzeciego włącznie można jakoś obejść się bez fizycznego urządzenia i jest to bardziej zaawansowana realizacja tego, co już widzieliśmy w pierwszym tutorialu. Chodzi tutaj o wirtualny kursor, który po skierowaniu naszego wzroku na jakiś przedmiot zmieni wygląd i przyklei się do oglądanej płaszczyzny, a także o reakcję samego przedmiotu. I tym zajmiemy się dzisiaj.

Do bardziej zaawansowanych rzeczy z ostatnich trzech części drugiego tutoriala (przecinanie kierunkowe, ustawianie hologramu zawsze przodem do nas, czy podążanie za nami) może kiedyś wrócimy. Nie ma emulacji kierunku patrzenia, fizyczne urządzenie byłoby tutaj wskazane. Póki co, nie próbowałem odpalać na emulatorze.

Przykłady z akademii sobie odpaliłem, ogólnie super, działają (no może z wyjątkiem tego z pierwszego tutoriala, ale po zmianie kodu też poszedł). Aha, natrafiłem jeszcze na szkolenie Pluralsight zatytułowane HoloLens Development Fundamentals, które też mogę polecić. Tam są podstawy, ale zrealizowane w całości własnoręcznie, nawet kursor.

Czy jednak tworzenie - w sumie dość podstawowej rzeczy - jaką jest kursor i reakcja na spojrzenie - nie może być bardziej szybkie i proste? Może.  Przy pomocy HoloToolkit, a właściwie HoloToolkit-Unity, z którego dziś skorzystamy. Gwoli ścisłości, tutoriale z akademii i wspomniana kiedyś przeze mnie książka też używają pewnych elementów tego toolkitu, ale z początkowej, starej wersji. My dziś skorzystamy z najnowszej wersji, która różni się od tej początkowej dość istotnie. Upraszcza implementację i wprowadza infrastrukturę w postaci interfejsów. Dobrze opisuje to post Unity 5.5 and the HoloToolkit – Changes in Input when Developing HoloLens Apps. Generalnie jednak jakoś ta wiedza nie jest szeroko promowana…

Jak rozpocząć korzystanie z toolkitu w Unity?  Rzuciłem okiem na stronkę GetStarted, pobrałem gotową wersję i na kopii swojego projektu z sześcianem zaimportowałem pakiet HoloToolkit-Unity-v1.5.5.0.unitypackage do Unity (Assets -> Import Package -> Custom Package…). Jakich elementów użyć, by kursor nam działał i coś się działo na obiekcie?  Wobec braku dobrych tutoriali, znalazłem gdzieś na forum, że najlepiej sobie obejrzeć testowe sceny (po zaimportowaniu toolkitu w Assets > HoloToolkit > Input > Tests > Scenes), co też uczyniłem.

A teraz już do dzieła!

Czego potrzebujemy, by mieć kursor, który odpowiednio zachowa się na przedmiocie 3D?  Przeciągamy InputManager.prefab z Assets > HoloToolkit > Input > Prefabs do panelu Hierarchy.  Kursor wybieramy sobie z Assets > HoloToolkit > Input > Prefabs > Cursor. W naszym przypadku chcemy zmieniać jego postać po skrzyżowaniu naszego wzroku z przedmiotem i dobry będzie to tego Cursor.prefab. Przeciągamy go podobnie jak poprzednio do Hierarchy.

Projekt Unity eksportujemy tak jak w poprzednich postach do projektu Visual Studio i uruchamiamy na emulatorze (chyba że ma ktoś urządzenie). Gdy nie patrzymy na sześcian to kursor jawi się jako światełko:

CaptureC

Jak spojrzymy na sześcian, to kursor przybierze wygląd pierścienia przyległego do ściany:

CaptureD

Jak kierować spojrzeniem w emulatorze? Klikam i przeciągam myszą albo naciskam sobie klawisze strzałek na klawiaturze. Chodzenie to z kolei mogą być klawisze W, A, S i D. Wiecej o używaniu emulatora na stronie Using the HoloLens emulator.

A dlaczego nie zrobiłem póki co spoglądania na zielony, animowany szkielet, jaki mam w HoloVision2? Przymierzałem się, ale natrafiłem na kilka przeszkód. W inspektorze sześcianu na scenie jest coś takiego jak collider (tutaj box collider, są też inne rodzaje), automatycznie dodany. Bez elementu collider na modelu nie będą wykrywane kolizje i kursor będzie się zachowywać tak, jakby niczego tam nie było. W przypadku bardziej złożonych modeli możemy dodać do nich w inspektorze mesh collider otaczający wybrany mesh z modelu dokładnie takim jak on kształtem. Nie jest to jednak wydajne rozwiązanie, jeśli model animujemy. Collider typu mesh jest kosztowny w obliczeniach. Możemy wtedy dla poszczególnych części modelu poustawiać elementy collider (mesh czy bardziej wydajne jeśli nie stracimy dużo na kształcie - box, sphere czy capsule). Astronauta z akademii HoloLens jest tak właśnie zrobiony. O obiektach collider można poczytać w tutorialach z importu modeli do Unity czy książkach o tym środowisku. Okazuje się, że można nawet automatycznie próbować wygenerować collider-y za pomocą opcji Generate Colliders w inspektorze modelu z Assets. Na moim szkielecie nic się jednak samo nie wygenerowało. Mesh w tym modelu jest tylko jeden i dotyczy całej postaci w pozycji leżącej, jak ręcznie dodam do niego mesh collider to dotyczy on także pozycji leżącej, nawet jeśli szkielet stoi i jak trafię w collider to kursor może się zmienić, ale trzeba liczyć na łut szczęścia. Astronauta Microsoftu ma wiele elementów mesh w sobie, co ułatwia zdaje się tworzenie collider-ów dla poszczególnych części. Na razie temat zostawiam, może do niego wrócę za jakiś czas, zobaczymy.

Teraz reakcja obiektu na spojrzenie. Można stworzyć w Assets Unity własny skrypt w C# (prawy przycisk –> Create –> C# script), edytować go w Visual Studio poprzez podwójne kliknięcie i potem podpiąć do obiektu na scenie poprzez przeciągnięcie na jego zakładkę Inspector (albo od razu przez Add Component w inspektorze). Ja poszedłem jeszcze bardziej na skróty i podpiąłem skrypt FocusedObjectColorChanger z testów toolkita (Assets > HoloToolkit > Input > Tests > Scripts).

CaptureA

Jak nazwa wskazuje ustawia kolor obiektu na wskazany, jeśli spojrzymy na niego.  Oto kod:

   [RequireComponent(typeof(Renderer))]
   public class FocusedObjectColorChanger : MonoBehaviour, IFocusable
   {
       [Tooltip("Object color changes to this when focused.")]
       public Color FocusedColor = Color.red;

       private Color originalColor;
       private Material cachedMaterial;

       private void Awake()
       {
           cachedMaterial = GetComponent<Renderer>().material;
           originalColor = cachedMaterial.GetColor("_Color");
       }

       public void OnFocusEnter()
       {
           cachedMaterial.SetColor("_Color", FocusedColor);
       }

       public void OnFocusExit()
       {
           cachedMaterial.SetColor("_Color", originalColor);
       }

       private void OnDestroy()
       {
           DestroyImmediate(cachedMaterial);
       }
   }

Widzimy dość prostą klasę C#, która standardowo w przypadku skryptów dziedziczy po MonoBehaviour, a w przypadku obsługi focusa ze spojrzenia i w nowym HoloToolkicie dodatkowo implementuje interfejs IFocusable. Efekt działania prezentuję poniżej:

CaptureB

W przykładach toolkitu widziałem jeszcze skrypt GazeResponder, który podświetla materiał (trochę podobnie jak w przypadku astronauty w akademii HoloLens).

Dzisiejszy przykład udostępniłem na github jako HoloVision3.

Zabawa z HoloLens trwa nadal. Do zobaczenia w następnym odcinku.

środa, 8 marca 2017

[DSP2017] 3# Holowizja - Tańczący szkielet

Witam serdecznie. Ostatnio prezentowałem sześcian, dziś zrobimy coś nieco bardziej wyrafinowanego, choć nadal bez jednej linijki w C#. Będzie to ruszający się szkielet w zielonym świetle.

Na początku potrzebujemy model 3D, najlepiej w dość uniwersalnym formacie FBX. W sieci można znaleźć całkiem sporo darmowych i płatnych modeli. Unity oferuje je poprzez Asset Store. Inne przykładowe strony to:  http://tf3dm.com/, https://www.cgtrader.com/, https://www.turbosquid.com/. Na potrzebę dzisiejszej wizji wybrałem model Skeleton - PBR - Animated - Low Poly.

Mamy model, rozpakowujemy. Dostajemy zbiór plików, w tym pliki .FBX z nieruchomym szkieletem i różne jego animacje, a także tekstury czy coś takiego jak “normal map”. Jak zaimportować to do Unity?  Generalnie polega to na tym, że przeciągamy plik .FBX do folderu Assets w projekcie (jak poniżej), ale to nie wszystko. Jak przeciągniemy z Assets nasz model na scenę, to zobaczymy, że nie ma załadowanych tekstur i się nie rusza (jeśli zaimportowaliśmy model z animacją). W osiągnięciu pożądanego celu pomogło mi obejrzenie trzech filmików szkoleniowych na YouTube: 17 Unity: Importing FBX Files, Unity Tutorial #3 - Importing FBX assets in Unity, How to Import and Animate FBX file on Unity 5. Ostatni jest najlepszy.

Naładowani pewną dawką wiedzy, przystępujemy do dzieła. Na początek uporządkujmy nieco foldery w Assets. Tworzę foldery Characters, Skeleton, Animations, Scenes i Textures. Do Characters/Skeleton wrzuciłem nieruchomy szkielet i folder Materials, do Animations animowany szkielet, do Scenes plik sceny powstały z jej zapisania, do Textures pliki z Unity5_MetalRough_Texs w modelu. Do Materials dorzuciłem plik z NormalMap w modelu (powinien być oznaczony w zakładce Inspector jako normal map, o czym przypomni w odpowiednim momencie samo Unity i to zrobi).

image

image

Konfiguruję zaznaczony materiał.

image

W zakładce Inspector wybrałem shader Bumped Diffuse, a następnie wybrałem odpowiednie pliki graficzne za pomocą przycisków Select.

image

Model na scenie nabrał kolorów, ale jest za duży jak na HoloLens. W inspektorze w sekcji Model ustawiam skalę na 0.3 (można to zrobić przed importem do Visual Studio i do HoloLens). Aha, wcześniej ustawiłem jego pozycję na scenie na 0, –0.1, 2.5 i rotację Y na 180 (jak w poprzednim poście), a światło na scenie zrobiłem sobie zielone z większą intensywnością i nieco je przesunąłem.

image

Szkielet jednak nadal się nie rusza na poglądzie “gry”, a na dole w inspektorze animowanego modelu można znaleźć sekcję, w której można obejrzeć sobie jego ruchy.

image

W Assets wybieram Create, a następnie Animator Controller. Nadaję mu odpowiednią nazwę (u mnie AC Skeleton).

image

Przeciągam stworzy kontroler animacji na pole Controller w sekcji Animator w inspektorze modelu na scenie.

image

Przeciągam składową Take 001 z animowanego modelu w Assets na schemat kontrolera animacji. Pojawia się pomarańczowy element Take 001 połączony z blokiem Entry.

image

Teraz jak puszczę podgląd sceny, to szkielet się rusza, ale zatrzymuje się po jakimś czasie. Co zrobić, by ruszał się ciągle? W inspektorze animowanego modelu w Assets znajdujemy sekcję Take 001 i zaznaczamy check Loop Time.

image

Całość eksportuję z Unity do Visual Studio analogicznie jak w poprzednim poście. W emulatorze HoloLens mogę zaobserwować taniec zielonego szkieletu:

image

Źródła dzisiejszego projektu można znaleźć na github w folderze HoloVision2.

To tyle na dziś. Import animowanego modelu 3D do Unity mamy za sobą. W najbliższym czasie zaczniemy badać funkcjonalności specyficzne dla HoloLens.

sobota, 4 marca 2017

[DSP2017] 2# Holowizja - Holo World

By pisać na HoloLens od czegoś trzeba zacząć. Nie od razu Kraków zbudowano. Na pierwszy ogień poszło coś w stylu holistycznego Hello World aka Holo World, czyli sześcian jaki powinien pojawić się przed naszym nosem po założeniu okularów.

Na początek narzędzia. Nowe Unity nie wymaga dedykowanej wersji dla HoloLens jak kiedyś. Co do Visual Studio, potrzebna jest wersja 2015 najlepiej z Update 3. Na mojej maszynie zdarzyło się, że emulator HoloLens na początku nie chciał działać. Odinstalowałem Hyper-V i na nowo zainstalowałem, potem to samo uczyniłem z emulatorem i poszło.

Teraz kilka absolutnych podstaw. Tworzymy projekt 3D w Unity (Unity nie jest wymagane, ale jest preferowanym środowiskiem, w którym najłatwiej tworzyć dla HoloLens).

  • Główną kamerę pozycjonujemy na 0, 0, 0
  • Clear Flags ustawiamy na Solid Color, a tło na kolor czarny, który w Holo Lens będzie interpretowany jako przezroczysty (czyli realne otoczenie)
  • Clipping Planes kamery zmieniamy na 0.85
  • W Hierarchy przez Create tworzymy sześcian, zmieniamy jego pozycję, rotacje i skalę (skalę na 0.25 by się nam zmieścił po założeniu okularów) i zapisujemy scenę w menu File.
  • Testowo możemy sobie odpalić nasz filmik za pomocą przycisku odtwarzania u góry (na razie nic się szczególnego nie dzieje, nieruchomy sześcian)

To streszczenie 3 pierwszych “rozdziałów” z pierwszego tutoriala Holograms 100: Getting started with Unity z Holographic Academy Microsoft, która jak najbardziej wydaje sie godna polecenia.  Sześcian po sam początek jest najlepszy, dobrze na nim widać efekty zmian pozycjonowania i rotacji wzdłuż trzech osi.

image

Mamy już projekt w Unity, teraz wyeksportujmy go do Visual Studio. W końcu przecież mamy doczynienia z odmianą, co prawda dość wyjątkową, aplikacji uniwersalnej na Windows 10. Wykonujemy kilka kroków, które dobrze opisane są w rozdziale 4 z Holograms 100: Getting started with Unit. Jedynie nie zmieniałem MaxVersionTested na wartość z tutoriala (u mnie wygenerowała się wersja emulatora, czyli 10.0.14393.0)

image

Póki co nie piszemy ani linijki kodu. Ustawiamy całość na Release, x86 i wybieramy HoloLens Emulator (chyba że ma ktoś fizyczne urządzenie). Uruchamiamy bez debugowania. Najpierw oczywiście wstaje Windows na emulatorze okularów, potem pojawia się na chwilę ekran startowy naszej aplikacji z logiem Unity (na potrzeby edukacji nie przeszkadza), a potem dostajemy już poniższy widok:

image

Pierwsze Holo World za nami. Mam pewną wizję wizji, którą chciałbym docelowo sobie stworzyć, ale w najbliższym czasie dalej będę eksperymentować z tym, co oferuje HoloLens.

Aha, źródła trafiają na https://github.com/MarcinKruszynski/HoloVision. Dzisiejsza próba to HoloVision1.

Uwaga, wyczaiłem moim zdaniem całkiem niezłą książkę na temat HoloLens o tytule “Develop Microsoft HoloLens Apps Now”.

9781484222010

To tyle na dziś, widzimy się w następnym odcinku, czy też bardziej poście –Smile

czwartek, 2 marca 2017

[DSP2017] 1# Holowizja - intro

Inicjatywa http://dajsiepoznac.pl wydaje się jedyna w swoim rodzaju. To coś jakby na wzór przeglądu kapeli muzyki alternatywnej, gdzie każdy pomysł czy technologia, nawet coś najbardziej odjechanego jest w zasadzie możliwe.  Ostatnio trochę nie pisywałem, ale to właśnie dlatego by nabrać trochę sił przed startem.

Tegoroczny pomysł kontynuuje rozrywkowe podejście z roku ubiegłego, ale w innej materii. O ile poprzednio były to aplikacje mobilne, o tyle teraz też będę mobilne, ale holograficzne !!!  Dodam, że  póki co nie posiadam magicznych okularów za 12 koła, ale to może i lepiej dla DSP, bo będę odbywał holograficzną wędrówkę tak jak każdy z nas. Może uda się nieco odczarować dużą tajemniczość i małą popularność holograficznej wersji Windows 10. Pokażemy co się za tym kryje i jaką wiedzę, narzędzia z innych bardziej znanych nam dziedzin można tutaj wykorzystać.

Oderwijmy się od codzienności i odlećmy!  Po godzinach zróbmy coś dla fanu i dobrej zabawy, coś diametralnie zgoła innego. Załóżmy magiczne okulary (nawet ich nie mając) i do dzieła. Każda wizja powstała w głowie może się przed nami zwizualizować, niczym we śnie, halucynacji, grze czy bajce. Jak choćby inwazja dużych pająków w naszym pokoju…

HoloLens2

Czy to nie jest wspaniałe, móc widzieć to czego nie ma?  Słyszeć to, czego nie słychać?  Co więcej, kilka osób może współdzielić te halucynacje…

Hololens-Teomirn-fortepian

czy nawet się stać duchami, zjawami, ewentualnie zombi dzięki holoportacji…

holoportation-demo

Dodam, że HoloLens może służyć nie tylko do rozrywki, ba może rozrywkowe zastosowania nie stanowią tu nawet większości zastosowań…

Jako że generalnie jestem od zawsze związany z szeroko rozumianą platformą .NET, również i tutaj będzie C#, tyle że stosowany ze środowiskiem Unity, z którym wcześniej nie miałem doczynienia. Ale może to i lepiej, bo będzie więcej edukacji na łamach DSP i całość może okazać się bardziej przystępna niż ostatnio.  Niewykluczone, że dodatkowo w którymś momencie sięgnę po narzędzie Maya czy 3ds Max znane z czasów studiów, a wtedy wyrenderowałem sobie filmik z pochodem szkieletów we mgle (czy może smogu?) przy przygnębiającym żółtym świetle latarni ulicznych… 

Nie zamykam się wyłącznie na platfomę .NET czy C#. W zeszłym roku były u mnie  Java i Swift, niewykluczone że w tym roku odjadę jeszcze bardziej także i na tym polu. Nie wiem czy dam radę od razu w ramach samego projektu w tych ramach czasowych, ale dzięki tegorocznej formule DSP może pojawią się jakieś luźniejsze posty na temat Pythona czy R.  Języki te są obecnie bardzo istotne dla uczenia maszynowego, w nich powstaje najwięcej frameworków i bibliotek związanych z tą dziedziną. Zawsze przecież nasze holograficzne monstrum może się uczyć i próbować wyciągać wnioski z otaczającego nas świata! 

niedziela, 20 listopada 2016

MSFConnect 2016 - małe podsumowanie

Ostatnio trochę nie pisałem postów tutaj, ale nic na siłę. Nie kieruję się zasadą by pisać jakiś jeden post dziennie, ale bardziej “na miękko”. Nie znaczy że nie mógłbym tak robić, ale nadal wolę poświęcać więcej czasu na mocne techniczne tematy, nawet gdyby miało to być towarem znacznie bardziej limitowanym. Na pewno będą tutaj trafiać kolejne, bardziej wyszukane już praktyczne zagadnienia związane z platformą Xamarin. Do bardziej luźnego komentowania wystarcza mi póki co twitter, na którym ostatnio dość aktywnie się udzielam. A teraz zróbmy małe podsumowanie nowości z Microsoft Connect (); 2016.

Co prawda wszystko, co chciałem obejrzeć, skomentowałem już na twitterze, ale teraz jakoś pora to zebrać w całość i podsumować.

Znaczenie platformy .NET rośnie:

  • więcej krajów i programistów
  • Samsung dołącza do grupy firm mających wpływ na rozwój .NET. Dostajemy próbne wsparcie .NET Core i Xamarin.Forms dla systemu Tizen (a to dużo urządzeń mobilnych, zegarków i telewizorów)
  • Google Cloud zaczyna wspierać .NET

Duża inwestycja w Mac-a:

  • Visual Studio for Mac Preview będący ewolucją Xamarin Studio z projektami ASP.NET Core i mobilnymi Xamarin (jeśli korzystamy z komercyjnej wersji VS na Windows, wersja na Mac będzie za darmo w ramach tej subskrypcji, poza tym jest wersja darmowa Community)

Duży rozwój Xamarin

  • Visual Studio for Mac
  • Xamarin.Forms: wsparcie dla systemu Tizen, w XAML osadzanie natywnych kontrolek z data bindingiem np. z Android i iOS, wywoływanie natywnego API z poziomu kodu strony forms, podgląd w designerze widoku strony dla Android, iOS i Windows
  • symulator iOS w Windows w VS 2017
  • Xamarin Test Recorder: generowanie testów po interakacji z urządzeniem, eksport do kodu lub na farmę urządzeń w Test Cloud, możliwość bezpośredniego odpalenia testów w Visual Studio Enterprise
  • Visual Studio Mobile Center Preview (VS w chmurze do tworzenia i zarządzania projektami mobilnymi)

Duże inwestycje w system Linux:

  • Microsoft dołącza oficjalnie do Linux Foundation
  • Dostajemy pierwszą odsłonę SQL Server na Linux (można się z nim łączyć także przez Management Studio na Windows czy Visual Studio/Visual Studio Code)
  • Na Windows 10 rozwijany jest podsystem dla Linux (m.in obsługa większej ilości linuksowych narzędzi, 24-bitowe kolory w konsoli i obsługa myszy, wywoływanie z PowerShell rzeczy linuksowych, a z bash programów Windows)
  • Debugowanie aplikacji C++ na Linux z poziomu Visual Studio w Windows (połączenie zdalne z maszyną Linux lub z podsystemem Linux na lokalnym Windows 10)

Pojedynek ASP.NET kontra node.js

  • bardzo duża przewaga w benchmarku ASP.NET Core nad node.js (w Linux i Windows), Go czy innymi jeszcze rozwiązaniami

Rozwój SQL Server:

  • wersja na Linux
  • współpraca Management Studio i Visual Studio z instancjami na Linux
  • wsparcie dla cross-platformowego Visual Studio Code
  • udostępnienie sporej liczby funkcjonalności znanych do tej pory z Enterprise do wersji podstawowej, a nawet express
  • rozwój providerów dla różnych języków i platform np. .NET Core, node.js, Java, Python, itd.

Visual Studio 2017 RC:

  • modułowa lekka instalacja tylko tego, co potrzebujemy, także w trakcie korzystania
  • kilkukrotnie lepsza wydajność: startowanie, ładowanie solution, kompilacja, mniejsze zużycie pamięci
  • Live Unit Testing - zielone checki, czerwone krzyżyki lub niebieskie znaczki, każda linijka kodu na bieżąco pokazuje status względem unit testów, który wykonują się w tle
  • analiza kodu i walidacja architektury w czasie rzeczywistym
  • nowy null exception helper - pokazuje co faktycznie było null-em
  • możliwość pokazania, który nawias w kodzie jest do czego
  • szybka wyszukiwarka wszystkiego w projekcie CTRL + T (jakby coś inspirowane R#), z przyciskami zmiany kontekstu na dole
  • kropeczki w kodzie - sugestie refaktoryzacji kodu (jakby coś ala R#)
  • propozycje zmian w kodzie (poza sugestiami)
  • wyszukiwarka Intellisense z przyciskami zmiany kontekstu na dole
  • czytelny i znacznie bardziej bogaty podgląd referencji do elementu w kodzie
  • otwarte definiowanie zbiorów plików do kompilacji w pliku projektu (pliki nie muszą być dokładnie wyszczególnione)
  • bardziej bogata i jasna wizualizacja referencji projektu
  • wstawianie breakpointa w dowolnej linii kodu podczas debugowania
  • projekt Class Library (.NET Standard)
  • zintegrowany .NET Core Tooling
  • zuinifikowane narzędzia dla wszystkich platform .NET dzięki rozszerzonemu MSBuild
  • aplikacje uniwersalne Windows: udogodnienia w edytorze XAML, XAML edit & continue, diagnostyka UI, edytor asset-ów
  • aplikacje desktop: udogodnienia w edytorze XAML, XAML edit & continue
  • aplikacje mobilne każdego rodzaju: zaawansowane profilowanie, inspekcja, szybsze i bardziej stabilne buildy
  • symulator iOS w Windows
  • aplikacje Web: nowy edytor JavaScript zgodny z najnowszymi standardami, lintery, debugowanie kodu klienta i serwera przy użyciu Chrome (wcześniej tylko Edge / IE), udoskonalony Browser Link
  • JavaScript: bogatszy Intellisense, składnia ES6+, składnia JSX, moduły Commonjs i ES6, transpilacja niskiego poziomu, rozszerzone wsparcie dla JSDoc
  • szybkie tworzenie aplikacji .NET Core w Dockerze na Linuksie i w chmurze
  • większe wsparcie dla Linux (nowe projekty C++, debugowanie na zdalnej maszynie Linux (SSH), dołączanie się do jej procesu, komunikowanie się z lokalnym podsystemem Linux na Windows 10 poprzez konsolę)
  • wsparcie dla ponad 20 języków, w tym także Swift

C#7 - był już znany przed konferencją

.NET Standard 2.0 - było już przed konferencją, ale powiem że to godny następca Standard 1.x, który był następcą PCL, będzie można współdzielić coraz większe ilości kodu pomiędzy klasycznym .NET (np. desktop, ASP.NET), .NET Core (UWP, ASP.NET Core), a Mono (Xamarin)

.NET Core:

  • .NET Core 1.1
  • nowe dystrybucje: Linux Mint 18, OpenSUSE 42.1, macOS 10.12, Windows Server 2016
  • nowe API i poprawki bugów

Aplikacje uniwersalne Windows:

  • lepsze narzędzia w VS 2017
  • rozwój Device Portal dla każdego urządzenia z Windows 10
  • UWP Community Toolkit 1.2

ASP.NET Core 1.1:

  • URL Rewriting (z konfiguracją na IIS, Apache lub w C#)
  • wywoływanie komponentów widoku poprzez tag helpery
  • middleware jako filtry MVC
  • prekompilacja widoków Razor
  • Response Caching
  • dodawanie kompresji GZip do response w HTTP
  • wsparcie dla Azure

TS 2.0:

  • typy nie-nullowalne
  • modularyzacja lib.d.ts
  • łatwiejsze pobieranie plików .d.ts
  • tagowalne unie
  • globalne wsparcie w tsconfig.json
  • jawne typy this dla funkcji

TS 2.1:

  • funkcje async
  • lepsza inferencja typów
  • lepsze wsparcie przez edytor

 

Jak widać przyszłość jak zwykle rysuje się ciekawie. W przeglądzie skupiłem się na wybranej tematyce, nie zagłębiałem się w nowości np. Visual Studio Code czy usług Azure.

Do powyższych nowinek z Connect dodam, że ostatnio ukazała się kompilacja Windows 10 14971, która:

  • zawiera czytnik e-booków w przeglądarce Edge
  • pozwala zamiast konsoli cmd.exe wywoływać konsolę PowerShell

niedziela, 2 października 2016

Xamarin.Forms kontra Xamarin odc.3 (uprawnienia, media library, dependency service)

Xamarin.Forms kontra Xamarin, witam serdecznie. Przed nami kolejny odcinek z luksusowej różowej edycji. Dziś będzie dość zwięźle i krótko. Generalnie odpowiemy na dwa pytania. Pierwsze: jak pobrać listę utworów muzycznych, by dało się ją wyświetlić na liście w Xamarin.Forms? I drugie: jak uporać się z uprawnieniami, do których nie ma uniwersalnej infrastruktury? No to zaczynamy!

Na obecny moment app-ka z LightOrgan/Xamarin.Forms ładuje listę kawałków muzycznych na Android i iOS:

Screenshot_20161002-221607  IMG_0061

Ktoś powie, że to może niewielki przyrost od ostatniego razu, ale ostatnio miałem nieco mniej czasu, a poza tym obsługa uprawnień w Xamarin.Forms wymagała chwilki zastanowienia (czemu nie ma jakiegoś uniwersalnego API?). Koniec końców natrafiłem na świetny post Simplified iOS & Android Runtime Permissions with Plugins!. Przedstawione tam rozwiązanie zostało zamknięte w pakiecie nuget Plugin.Permissions ze źródłami na https://github.com/jamesmontemagno/PermissionsPlugin, do których dopisałem sobie obsługę Media Library od iOS 9.3. Do enum-a Permission dodałem Media i obsłużyłem to jedynie w iOS wzorując się na obsłudze uprawnienia Photos. W klasie PermissionImplementation sprowadziło się to głównie do dodania takich elementów:

        PermissionStatus MediaPermissionStatus
        {
            get
            {
                if (UIDevice.CurrentDevice.CheckSystemVersion(9, 3))
                {
                    var status = MPMediaLibrary.AuthorizationStatus;
                    switch (status)
                    {
                        case MPMediaLibraryAuthorizationStatus.Authorized:
                            return PermissionStatus.Granted;
                        case MPMediaLibraryAuthorizationStatus.Denied:
                            return PermissionStatus.Denied;
                        case MPMediaLibraryAuthorizationStatus.Restricted:
                            return PermissionStatus.Restricted;
                        default:
                            return PermissionStatus.Unknown;
                    }
                }
                else
                {
                    return PermissionStatus.Granted;
                }                  
            }
        }

        Task<PermissionStatus> RequestMediaPermission()
        {
            if (UIDevice.CurrentDevice.CheckSystemVersion(9, 3))
            {
                if (MediaPermissionStatus != PermissionStatus.Unknown)
                    return Task.FromResult(MediaPermissionStatus);

                var tcs = new TaskCompletionSource<PermissionStatus>();

                MPMediaLibrary.RequestAuthorization(status =>
                {
                    switch (status)
                    {
                        case MPMediaLibraryAuthorizationStatus.Authorized:
                            tcs.SetResult(PermissionStatus.Granted);
                            break;
                        case MPMediaLibraryAuthorizationStatus.Denied:
                            tcs.SetResult(PermissionStatus.Denied);
                            break;
                        case MPMediaLibraryAuthorizationStatus.Restricted:
                            tcs.SetResult(PermissionStatus.Restricted);
                            break;
                        default:
                            tcs.SetResult(PermissionStatus.Unknown);
                            break;
                    }
                });

                return tcs.Task;
            }
            else
            {
                return Task.FromResult(PermissionStatus.Granted);
            }           
        }

Uprawnienia sprawdzam w aplikacji Xamarin.Forms podczas jej uruchamiania i wznawiania. W klasie App wygląda to tak:

        protected override async void OnStart()
        {
            await CheckPermissions();
        }

        …

        protected override async void OnResume()
        {
            await CheckPermissions();
        }

        private async Task CheckPermissions()
        {
            try
            {
                var permissionsList = new List<Permission>();

                if (Device.OS == TargetPlatform.Android)
                {
                    var status = await CrossPermissions.Current.CheckPermissionStatusAsync(Permission.Storage);

                    if (status != PermissionStatus.Granted)
                        permissionsList.Add(Permission.Storage);

                    status = await CrossPermissions.Current.CheckPermissionStatusAsync(Permission.Microphone);

                    if (status != PermissionStatus.Granted)
                        permissionsList.Add(Permission.Microphone);                  
                }
                else if (Device.OS == TargetPlatform.iOS)
                {
                    var status = await CrossPermissions.Current.CheckPermissionStatusAsync(Permission.Media);

                    if (status != PermissionStatus.Granted)
                        permissionsList.Add(Permission.Media);
                }

                if (permissionsList.Count > 0)
                {
                    var results = await CrossPermissions.Current.RequestPermissionsAsync(permissionsList.ToArray());

                    if (results.Any(p => p.Value != PermissionStatus.Granted))
                        await MainPage.DisplayAlert(AppResources.Permissions, AppResources.NotAllPermissionsMsg, "OK");
                }
            }
            catch (Exception ex)
            {               
            }
        }

Dodatkowo uprawnienia sprawdzam też na stronie FileListPage. Mankamentem stron w Xamarin.Forms jest fakt, że nie mają zdarzenia czy metody wywoływanej tuż po załadowaniu bądź wyświetleniu strony. Skorzystałem z metody OnAppearing, która - jak nazwa wskazuje - wywołuje się tuż przed wyświetleniem strony:

       protected override async void OnAppearing()
       {
           base.OnAppearing();

           var hasPermission = await CheckPermission();

           if (hasPermission)
           {
               allMediaItems = await DependencyService.Get<IMusicService>().GetItemsAsync();                 
           }
           else
           {
               allMediaItems = new List<MediaItem>();

               await DisplayAlert(AppResources.Permissions, string.Format(AppResources.PermissionDeniedMsg, GetPermissionName()), "OK");               
           }

           SearchFiles();
       }

       private async Task<bool> CheckPermission()
       {
           var status = PermissionStatus.Denied;

           if (Device.OS == TargetPlatform.Android)
              status = await CrossPermissions.Current.CheckPermissionStatusAsync(Permission.Storage);
           else if (Device.OS == TargetPlatform.iOS)
              status = await CrossPermissions.Current.CheckPermissionStatusAsync(Permission.Media);

           return status == PermissionStatus.Granted;
       }

       private string GetPermissionName()
       {
           if (Device.OS == TargetPlatform.Android)
               return "READ_EXTERNAL_STORAGE";
           else if (Device.OS == TargetPlatform.iOS)
               return "Media library access";

           return string.Empty;
       }

Widzimy tutaj wywołanie tzw. dependency service, czyli serwisu w Xamarin.Forms, który ma różną implementację na każdej z platform (u mnie Android i iOS). Jego interfejs składa się póki co z jednej metody:

   public interface IMusicService
   {
      Task<List<MediaItem>> GetItemsAsync();
   }

Implementacja na Android przedstawia się następująco:

[assembly: Xamarin.Forms.Dependency(typeof(AndroidMusicService))]

namespace LightOrganApp.Droid
{
    public class AndroidMusicService : IMusicService
    {
        public async Task<List<MediaItem>> GetItemsAsync()
        {
            return await Task.Run(() =>
            {
                var items = new List<MediaItem>();

                try
                {
                    var projection = new string[]
                    {
                        MediaStore.Audio.Media.InterfaceConsts.Id,
                        MediaStore.Audio.Media.InterfaceConsts.Artist,
                        MediaStore.Audio.Media.InterfaceConsts.Title,
                        MediaStore.Audio.Media.InterfaceConsts.Duration,
                        MediaStore.Audio.Media.InterfaceConsts.Data,
                        MediaStore.Audio.Media.InterfaceConsts.MimeType
                    };

                    var selection = MediaStore.Audio.Media.InterfaceConsts.IsMusic + "!= 0";
                    var sortOrder = MediaStore.Audio.Media.InterfaceConsts.DateAdded + " DESC";

                    var cursor = Forms.Context.ContentResolver.Query(MediaStore.Audio.Media.ExternalContentUri, projection, selection, null, sortOrder);

                    if (cursor != null && cursor.MoveToFirst())
                    {
                        do
                        {
                            int artistColumn = cursor.GetColumnIndex(MediaStore.Audio.Media.InterfaceConsts.Artist);
                            int titleColumn = cursor.GetColumnIndex(MediaStore.Audio.Media.InterfaceConsts.Title);
                            int durationColumn = cursor.GetColumnIndex(MediaStore.Audio.Media.InterfaceConsts.Duration);                           

                            var item = new MediaItem(cursor.GetString(titleColumn), cursor.GetString(artistColumn), DateUtils.FormatElapsedTime(cursor.GetInt(durationColumn) / 1000));
                            items.Add(item);                         

                        } while (cursor.MoveToNext());
                    }                       
                }
                catch
                {                  
                }

                return items;
            });           
        }      
    }
}

a na iOS tak:

[assembly: Xamarin.Forms.Dependency(typeof(iOSMusicService))]

namespace LightOrganApp.iOS
{
    public class iOSMusicService : IMusicService
    {
        public async Task<List<MediaItem>> GetItemsAsync()
        {
            return await Task.Run(() =>
            {
                var query = new MPMediaQuery();
                var mediaTypeNumber = NSNumber.FromInt32((int)MPMediaType.Music);
                var predicate = MPMediaPropertyPredicate.PredicateWithValue(mediaTypeNumber, MPMediaItem.MediaTypeProperty);

                query.AddFilterPredicate(predicate);

                var unknownArtist = NSBundle.MainBundle.LocalizedString("unknownArtist", "Unknown Artist");

                return query.Items.Select(item => new MediaItem(item.Title, (item.Artist != null) ? item.Artist : unknownArtist, GetDisplayTime((int)item.PlaybackDuration))).ToList();
            });         
        }

        private string GetDisplayTime(int seconds)
        {
            var h = seconds / 3600;
            var m = seconds / 60 - h * 60;
            var s = seconds - h * 3600 - m * 60;

            var str = "";

            if (h > 0)
                str += $"{h}:";

            str += $"{m:00}:{s:00}";

            return str;
        }
    }
}

Podsumowując udało się nam współdzielić maksymalnie wszystko, co się dało w aplikacji Xamarin.Forms, rozdzielając jedynie szczegóły implementacyjne tam, gdzie było to niezbędne. To oczywiście dopiero wstęp do podpinania kodu opartego na natywnym API. W kolejnym kroku pasuje podpiąć odtwarzanie muzyki wraz z odpowiednimi notyfikacjami, a także z jawnym serwisem w tle w przypadku Android ( iOS  - jak dotąd w moich projektach -  używa systemowego odtwarzacza, który robi to w sposób niejawny). Ewentualnie może od razu podepnie się analizę FFT opracowaną jak dotąd w Android do sterowania światłami. Co z tego wyjdzie?  O tym w następnym odcinku. Stay tuned!