Hopstack

hopstack

Hello! We are developers from the Navigine company. We decided to test the Wi-Fi RTT technology and share the results with you. What is Wi-Fi RTT Wi-Fi RTT (Round-trip time) is a brand new technology that allows locating devices with unprecedented sub-meter accuracy. Basically, it measures the distance between a device and Wi-Fi routers which is way more accurate than using a GPS signal. The latter can’t provide an acceptable level of accuracy at all when it comes to indoor positioning. Wi-Fi RTT outperforms RSSI-based methods as well, thanks to reduced latency and better accuracy. The Use Today, this technology is the next step to improve services that use indoor positioning. We expect that its implementation will become a better solution for many industries. Wi-Fi RTT is applicable for tracking vehicles and cargo within warehouses and production plants. Comparing to BLE, this technology provides enhanced accuracy and reduced latency, making processes more rapid and reducing delays. It is effective for public hotspots as well, such as offices and malls, airports, exhibitions and not only. Indoor navigation is the solution users need for making their visits to public places more comfortable and enjoyable. Through this, they can plan their time effectively and find locations they need immediately. The Advantages Our solution goes further with unique algorithms that enhance the basic capabilities of Wi-Fi RTT. demonstrates a submeter accuracy in checkpoints 95% of the time and around 30 cm accuracy 50% of the time. The positioning engine is a particle filter combining Pedestrian Dead Reckoning (PDR), based on inertial sensors readings, and Wi-Fi RTT readings for correction. Meanwhile, the dynamic test shows that delay in position estimation does not exceed one second. The latter result is achieved by complementing Wi-Fi RTT measurements with PDR via particle filter. Semi-static test in our office The technology is not just an innovation in itself, but also a practical solution that improves business efficiency and customer experience. Wi-Fi RTT provides longer distance measurements and can be integrated into existing Wi-Fi network infrastructure. Current status Now, it is too early to refer to any cases, while we are currently working on raising experts interest from LinkedIn. We can see the real need for this technology, so the first implementations are coming soon in Q1 2020. Today, we have confirmed orders from a big carrier and one logistics company. Why Wi-Fi RTT? The industries using indoor positioning have to realize that often BLE is not the solution that meets their needs. Wi-Fi RTT is a significantly more relevant technology for many cases. Our solution based on Wi-Fi RTT delivers clear advantages for customers, including high accuracy, low latency, ease of use and integration. With just 2 weeks between order and integration, it is one of the most rapid and flexible solutions. The combination of high accuracy, availability, and low price, can make the technology an Indoor positioning market leader.

A Needle in a Haystack: How Wi-Fi RTT Takes Indoor Positioning to the Next Level

Finding enterprise use cases worth development dollars Earlier this year, the GSMA, the world’s most influential telecom consortium, published a paper detailing Some of them were compelling. Others, less so. fifteen blockchain use cases for mobile network operators . As an , I was happy to see this kind of attention given to my still-nascent field. (Is all press good press?) But as a founder whose ability to buy Chipotle burritos rests on how seriously and successfully telecom carriers adopt blockchain technology, the addition of those less compelling use cases had me worried. entrepreneur in the telecom and blockchain space The sad truth is that the blockchain world is rife with misinformation, poorly-thought-out applications, and centralized tech pretending it’s “de-”. If left to their own devices, I could imagine carriers attempting the use cases I saw as less promising and being forever turned off of blockchain. So, although it’s against my very nature as a native Midwesterner, I see no other alternative to raining on this particular parade. As Warren Buffett wisely said in his : '17 shareholder letter The less the prudence with which others conduct their affairs, the greater the prudence with which we must conduct our own. In this article, I’ll attempt to be a voice of prudence. The applications that the GSMA proposes range from great and world-changing to fundamentally flawed, and I’ll explore four of them in the sections that follow. In so doing, I’ll draw out lessons worth remembering not only in telecom but also in broader enterprise blockchain R&D. A quick note on methodology: as an IDEO CoLab Fellow last winter, I learned that new tech is most interesting when it is desirable (i.e., adds real value for real people), feasible (i.e., technologically possible), and viable (i.e., good business). Check out IDEO’s explanation here if you’re curious, but it’s easiest to just witness them in action. You’ll get it. #1: Smart contracts for 5G network management “To realise the 5G promise of ubiquitous access across various networks, CSPs will need to handle heterogeneous access nodes and diverse access mechanisms. Selecting the fastest access node for every user or machine will be a central challenge in the future. …Rules and agreements between the various access providing networks can be coded into autonomous smart contracts. These contracts can be dynamic in nature wherein any time a policy needs to be changed, only the contract code needs to be changed.” The GSMA’s first use case falls prey to a classic problem of outside-in entrepreneurship — it describes a solution that every consumer wants but no business will offer. Is it to connect to any network freely and get the best value for the best service? Of course! I don’t care who gives me four bars of LTE service as long as I can reliably stream the #7-ranked Michigan basketball game in the back of my Uber. desirable But from the carrier’s point of view, this solution is neither feasible nor viable. On the technological side, the use case makes a number of critical leaps into still-unknown areas of blockchain tech, but far more damning is the business critique: why would carriers ever give up control of their customers? Carriers have built empires by leveraging their network assets to attract customers and reduce churn. Would they really buy into a protocol that forces them to auction for every data session, text, and call? feasibility viability Sounds tautological, but it’s surprisingly easy to forget. Yes, real-time bidding for connectivity would be amazing. But if it ever exists, it will only be after a prolonged battle with operators the world over. The lesson here is for prospective entrepreneurs: keep the enterprise in mind when designing enterprise blockchain products. #2: IOT connectivity “While localised networks in for instance a manufacturing line can provide great benefits, self-organised global supply chains powered by IOT can help streamline processes that require a lot of paperwork and governance. This would shift the focus from centralised IOT platforms (in technology and governance) to self-governed mesh networks… IOT can also be used for automatic tracking for quality and conditional parameters during transports, switching of ownership and provenance use cases.” The GSMA offers up three use cases in the IOT space. Unfortunately, they all fall prey to the same problem — they’re smart, and should probably happen, but they probably shouldn’t happen on a blockchain. These use cases are : IOT management via blockchain is a use case well-explored by startups and large enterprises alike. They may even prove to be : IOT is a huge and growing industry, devices will get smarter and smaller over time, and managing devices efficiently is a huge, valid concern. feasible viable The problem arises, though, when we consider the of blockchain in this context given the problems we are asking it to solve. desirability As I understand it, the problem is that we can’t get good data about products flowing through a manufacturing line or a multinational supply chain, so we’re asking blockchain to help. Walmart, for instance, now mandates that farms that supply their stores leafy green vegetables enter “ ” that they’ve build in conjunction with IBM. detailed information about their food into a blockchain database But wouldn’t that “detailed information” be just as useful in a normal database? In my mind, this type of supply chain management is a poor use of blockchain. If you can’t trust your supply chain partners (or much less, the folks on your manufacturing line) to produce accurate data, it doesn’t matter whether you use a blockchain, a database, or a stone tablet to store it: your customers are still going to . Garbage in, garbage out. (Or, due to blockchain’s immutability, it’s more like garbage in, garbage forever.) get E. coli from your lettuce Blockchain is expensive, slow, and non-private. It costs significant time and resources to write to a blockchain. Barriers to entry are high. (Do Walmart’s farmers now have to own wallets or accounts with IBM?) The lesson here is never to use blockchain when a normal database will do. This is not to say that blockchain won’t have a place in IOT; I think it will. But I’m willing to bet that device security turns out to be a better use case than provisioning or self-maintaining supply chains, because the former is a better fit to the unique constraints and benefits of blockchain. #3: Fraud prevention The telecom industry has not yet found a way to effectively and sustainably prevent fraud. In a general sense, working together to combat interoperator fraud is a good way to start. Blockchain could for instance be used to govern access to fraud detection information shared between operators…another angle is fraud caused by delays in sharing [call detail records] between operators. As blockchain works in real-time, using a shared administration of network activity could help identity plausible fraudulent connections faster. Smart contracts could be deployed to actively enforce network usage compliance rules and help us resolve inter operator disputes easier. Surprise twist: I actually this upcoming use case! In fact, I like it so much that I’ve been working on it for the past year with . (Is that cheating?) like drect.ly From a standpoint, blockchain has some clear advantages over other solutions in fraud prevention. In fact, it’s so good that you get to (justifiably) recite the holy text of blockchain use cases: desirability This is a case when mutually-distrustful actors need to coordinate to maintain a shared version of the truth for an economically-valuable digital record. That sentence is why blockchain was created; in this use case, we’ve just replaced the economically-valuable digital record of bitcoin ownership to a record of which telecoms have provided how much coverage to which roaming customers. Those records, it turns out, are incredibly valuable (and therefore, if managed well, can sustain a business model). Every year, telecom carriers lose over $38 billion to fraud; even a relatively small dent in that number is large in absolute terms. viable My own incredible bias notwithstanding, I do recognize some challenges here with . Billions of records are exchanged daily, which poses scalability problems. These records expose significant, closely-held data about network usage and subscriber behavior, which poses privacy concerns. Governance is challenging, for it’s unclear how centralized my ownership of the code base makes this project. And how can you get bad actors to sign onto a platform that demands higher responsibility? feasibility All that said, these are solvable problems. And perhaps that’s another lesson: ensure that your use case is a great fundamental fit with the unique value prop of blockchain technology — and then prove the feasibility haters wrong. If you think about it, that’s really the only way that technology advances. any #4: Hosted services Distributed Ledger and/or Blockchain network operators are responsible for configuring the network and granting access to network participants. In general, they specify the use case(s) that the network is serving, and are often involved in managing the network in terms of software upgrades, arbitration services, etc. A network can be operated by a single entity or a federation of multiple, separate entities. As a strategy consultant at Deloitte, I helped write a . It generated over 100 million views before being lost to the sands of business-thought-pieces past, but I’ll always remember it as the first time that I learned John Hagel’s concept of innovation “ .” trends report on ecosystems thinking antibodies The SparkNotes version of Hagel’s idea is that antibodies (i.e., agents of resistance) arise in big organizations whenever change is coming. They fight for the preservation of the status quo that helped them rise to power, and, even if well-intentioned, they often stifle the speed of change by insisting that old rules, norms, and values govern fundamentally new contexts. For example, a new business unit might be shut down because it’s cannibalizing sales of the core product; that is judged by the old rule of “protect the core,” rather than the new reality that any player could release the cannibalizing product and it’s better to optimize for growth. In the blockchain context, antibodies take the form of centralized services masquerading as blockchain technology. In the old world, businesses want efficiency and control — but Proof of Work is deliberately inefficient, and blockchain networks are intentionally decentralized. When I read a use case like the “hosted services” from above, where blockchains are treated like permissioned databases, I can’t help but remember Hagel’s antibodies. The whole point of blockchain technology is to make public commitments that are impossible to reverse; to open up previously siloed networks; and to radically decentralize power, code, and economic value accrual. So, my final lesson is this: You’ll want to do so — believe me, as someone who has built these systems — but if you do, you’ll be further from the real promise of blockchain technology and closer to designing a really bad database. After living in a centralized world, decentralization feels innately wrong. But as we enter this new age of decentralized technology, we ought to remember that it’s okay to break all of the old rules. never surrender decentralization when designing blockchain use cases. In fact, that’s the whole point. To connect with Christian, reach out on Twitter ( @cdkeil ) or via email at christian [at] drect.ly.

Needles in the Blockchain Haystack

How do you find the job candidate who’s an exact fit for your organization? How do find the person you are going to marry? How do you locate the right house for you and your family? How about a pet that’s been missing? Worse yet, a child who’s been missing? As a society, we spend a lot of time looking for things. Individuals search for apartments to rent, cars to buy, and romantic partners to date. Businesses search for customers, employees, and suppliers. . Our goal is to enable people to use incentive programs and in order to solve some important problems facing the world today. We believe, in particular, that we can help people Although we tend to approach these searches as if they are unique, we at nCent believe that they appear distinct on the surface but are often subject to similar dynamics on a meta level blockchain technology find higher quality things in a fraction of the time and more efficiently than they might expect. Some search problems, like finding the closest Italian restaurant, are easy to solve. , for example, is more challenging because it may be unclear where to start and how to efficiently gather information. It’s obviously a high stakes situation, because it involves the welfare of a child — quite a bit different then satisfying a pasta hankering. But other search problems are more difficult and involve higher stakes. Finding a missing child Difficult searches are called problems. “needle in haystack” One of our guiding principles at nCent is our belief that these “haystack” problems can be optimally solved by combining decentralized networks, blockchain technology, and the right incentives programs. A ‘proof of concept’ for this approach happened in when DARPA (USA defense research agency) placed ten red balloons in secret locations around the U.S. and offered $40,000 to the first team to locate them all. The winning team solved this search problem by offering recursive incentives: Anyone who either correctly identified the location of a red balloon or someone whose information led to a person who identified the location of a red balloon was rewarded. For example, if Person A referred Person B who referred Person C who correctly identified the location of a red balloon, then all three people in this chain would get rewarded in some capacity. 2009 referred Even if you don’t know where the needle is in the haystack, you are still incentivized to help by referring others to get closer. If the tail end of your subtree finds the needle, you too will be rewarded. Everyone who contributes to the network can be absolutely sure that if their contribution is valuable, their reward will be commensurate with this value. This means that the person who finds the missing child the person who spread the word to the finder’s social media network will be rewarded. The person who refers a successful candidate for a specialized job the person who informed the referrer will be rewarded. These programs can reduce their overall cost with (Larger payouts for those who are “closer” in the chain to the final goal) Utilizing blockchain technology in this process enables the network to be transparent and to be audited by anyone at any time. and and recursive payout structures . These recursive programs are scalable and when designed correctly, have an upper bound on the cost of sponsoring them. Recursive incentives motivate people to inform other people of the search problem. When executed properly, these networks grow quickly and organically, increasing the statistical probability of finding the target. In fact, we believe that recursive incentives, where every node of the successful chain is rewarded, become increasingly more valuable as the search problem becomes more difficult. Spam is another common problem that we will address in a forthcoming post: The biggest hurdle to solving a haystack problem is growing the search network quickly enough so that the chance of identifying the needle increases exponentially. “Cashout: What Does it Mean to be Spammed with Money?” As the tail end of the network is further removed from the origin of the network, the spread of information will be more efficient than any other search process implemented in the marketplace. . The incentive structures implemented on our blockchain will be modular enough to apply to many types of search problems. The inclusion of “decentralized networks” and “blockchains” might sound like tech jargon, but in reality it’s just the underlying tech that enables you to give “asking your friends for help” a global reach! We fully recognize that each case will come with its own idiosyncrasies, ranging from economic constraints of the searcher to the psychological realities of how people respond to incentives To learn more about our work, email me directly at kk@ncnt.io . To stay in the nCent loop, hear me tweet and join our international telegram channel .

How We Can Find the Needle in a Haystack, Together

Pinpointing Root Causes of Application Performance Problems in Dynamic Environments Pinpointing the root cause of application performance problems in a dynamic environment often resembles a complicated game of hide-and-seek. A familiar analogy is that it’s like trying to find a needle in a haystack. This characterization illustrates the challenge but isn’t especially helpful in offering solutions. So, if the root cause of an application problem is the “needle” and the application environment is the “haystack,” how exactly would we go about restoring peak performance? Taking the analogy literally is actually a pretty good way to explore the various approaches to resolving application performance problems in dynamic, elastic, and transient infrastructure environments. So, exactly how would you go about finding a needle in a haystack? 1. Eliminate the haystack Probably the fastest way to find the needle is to burn the haystack. Or dumping the hay into a pool of water and waiting for the needle to sink to the bottom would also work. If we were really talking about needles and haystacks, fine — but we’re not. There are fundamental business reasons why more and more companies are turning to dynamic cloud-based deployments in the first place. We can pretty much reject the option of returning to monolithic, static infrastructure where identifying application performance cause-and-effect relationships is more straightforward. 2. Rummage for the needle manually We could sift through the pile of hay, strand by strand, until we find the needle. That’s basically the way traditional (APM) tools work. They throw a massive collection of data at us (albeit usually in nicely formatted charts and graphs) and require us to comb through it all to figure what went wrong. Actually finding the needle remains a laborious manual process. Somebody somewhere has to pore over the charts and graphs, make sense of the data, and connect the dots to discover the root cause. Such handwork analysis can take hours — even days. application performance monitoring That’s too long when application problems are leading to disgruntled customers. Of course, things would go faster if we assigned more staff to tackle the problem: the more people sifting through the hay, the sooner we’d find the needle. But convening a war-room assembly to interpret the data is still a labor-intensive, time-consuming effort. Already most CIOs are frustrated that so many man-hours are spent on troubleshooting instead of innovating and optimizing. Furthermore, and perhaps more significant, today’s liquid environments — where millions of dependencies are changing on the fly from moment to moment — are simply too complex and too fast-moving, with too many performance data points, for humans to analyze in a timely manner. It would take more people than any business has at its disposal to detect causal relationships among so much data and identify the component that’s causing the problem. 3. Locate the general area of the needle Using a metal detector or an X-ray would narrow down the approximate location of the needle within a haystack. This is more efficient than looking through the entire pile, but it’s still a lot of work. We still have to manually sift through the hay — just not as much. Similarly, a handful of modern APM solutions get us a step closer. Discovery agents collect and correlate myriad metrics and performance data points from various distributed elements across the application environment. The data is consolidated and presented in a unified, integrated “single pane of glass” view. We now have a clear, comprehensive picture of the of the performance problem, but we haven’t diagnosed the The hard work is still left to us. We still have to pore through charts and graphs of data — just not as much. Modern APM displays the data within a more meaningful framework that helps us narrow down our focus. symptoms root cause. Now, imagine the difficulty when the needle is constantly on the move. That’s exactly what’s happening with today’s highly dynamic environments. Servers are perpetually coming and going, auto-scaling up and down as needs dictate. Container technology and microservices architecture are even more transient — moving from host to host — and generate even more metrics. With our applications now having so many moving parts, trying to keep up with them and their topology by dissecting a plethora of charts and graphs is literally beyond human capabilities. Dynamic applications have millions of dependencies that need to be analyzed, and they’re ever changing. No sooner do we think we have a handle on how everything is working together than the landscape changes and we’re back to square one. Present-day application environments change too fast and too often for even the most talented troubleshooters. Even a relatively simple containerized environment like this one, with only 142 hosts, has more dependencies than a human being can track without software assistance. 4. Extract the needle automatically Ultimately, the best way to find the needle (especially if it won’t sit still) is to use a powerful magnet to pull it right out of the haystack and deliver it into your hands. In our analogy, a next-generation solution would be such a “magnet.” It zeroes in on an application problem’s root cause automatically, rendering time-consuming manual analysis unnecessary — the same way a magnet obviates the need to sift through the pile of hay. artificial intelligence–powered APM Artificial intelligence (AI) enables computers to do what they do best: absorb huge amounts of information and make sense of it faster and more thoroughly than is humanly possible. It applies sophisticated algorithms and context-rich diagnostics to detect and correlate causal relationships among data with millions of dependencies in microseconds. In essence, AI-enhanced monitoring analyzes the problem the same way we humans would, only faster. Artificial intelligence is able to perform almost instantaneously the analytical “heavy lifting” that takes us humans hours or days. From theory to reality: Dynatrace APM Artificial intelligence has been defined as “being able to perceive its environment and apply cognitive functions such as learning and problem-solving.” has been built on artificial intelligence so that it is able to Dynatrace APM auto-discover all components of the full technology stack end to end from the customers’ web browsers all the way down to the host infrastructure — map out the entire IT in an interactive visual display environment identify the millions of dependencies among websites, applications, services, processes, hosts, , and cloud infrastructure networks learn how it all works together and what constitutes normal behavior automatically detect, analyze, and prioritize anomalies and performance problems actually recommend solutions to the root cause of those problems And AI allows Dynatrace to do all this at a speed, scale, and precision that no human could ever match. Dynatrace gets to “know” applications. Its proprietary Smartscape technology continuously auto-discovers and monitors every aspect of every application. Sophisticated algorithms learn normal application performance patterns and proactively flag anomalies. The AI auto-adjusts baselines dynamically in real time to avoid false positives caused by preset static alerting thresholds. Application performance problems are seldom isolated, one-time events, and they’re usually symptoms of a larger issue. Dynatrace looks at all other transactions that used the same components around the same time to see if they also experienced problems. Artificial intelligence correlates events throughout the full technology stack — client side, server side, infrastructure level — to identify analogous issues and detect causal relationships. AI diagnostics analyze the vast amount of data collected to pinpoint the exact component that’s causing the problem. In today’s increasingly complex and fluid IT environments, interpreting data points with millions of dependencies in order to determine underlying casual relationships is more than humans can master by themselves. Only artificial intelligence can take the colossal volume of data and translate it into actionable solutions before problems hit customers. See for yourself what Dynatrace can do. Dynatrace offers a — the complete full-blown version, not a stripped-down demo — that auto-discovers and visually maps out your entire technology stack within minutes. free trial

Finding the Needle in a Haystack

Summarizing Large Datasets of Customer Feedback Using Retrieval-Augmented Generation (RAG)

Day 23: AVKit Integration – Playing Videos and Media in SwiftUI 🎬 Today, we’ll explore how to integrate AVKit into your SwiftUI project. AVKit is the framework that lets you play videos and audio seamlessly with built-in controls. Comments for Customization: player.play(): This starts video playback.
cornerRadius(10): This rounds the corners of the video view, making it visually appealing.
frame(height: 300): The video player is confined to a specific height, ensuring a clean layout. Here's the code for the implementation shown: import AVKit
import SwiftUI

struct VideoPlayerView: View {
    private var player = AVPlayer(url: URL(string: "https://www.example.com/samplevideo.mp4")!)

    var body: some View {
        VStack {
            VideoPlayer(player: player)
                .frame(height: 300)
                .cornerRadius(10)

            HStack {
                Button("Play Video") {
                    player.play()
                }
                .font(.headline)
                .foregroundColor(.white)
                .padding()
                .background(Color.blue)
                .cornerRadius(8)

                Button("Pause Video") {
                    player.pause()
                }
                .font(.headline)
                .foregroundColor(.white)
                .padding()
                .background(Color.red)
                .cornerRadius(8)
            }
            .padding(.top, 20)
        }
        .padding()
    }
}

struct ContentView: View {
    var body: some View {
        VStack {
            Text("Welcome to Video Player")
                .font(.largeTitle)
                .padding()

            VideoPlayerView()
        }
    }
} The full series is available on my profile and the components can also be found at shipios.app/components. Happy Coding! 🎨 Day 23: AVKit Integration – Playing Videos and Media in SwiftUI 🎬 Day 23: AVKit Integration – Playing Videos and Media in SwiftUI 🎬 Today, we’ll explore how to integrate AVKit into your SwiftUI project. AVKit is the framework that lets you play videos and audio seamlessly with built-in controls. AVKit SwiftUI Comments for Customization: Comments for Customization: player.play(): This starts video playback. cornerRadius(10): This rounds the corners of the video view, making it visually appealing. frame(height: 300): The video player is confined to a specific height, ensuring a clean layout. player.play(): This starts video playback. cornerRadius(10): This rounds the corners of the video view, making it visually appealing. frame(height: 300): The video player is confined to a specific height, ensuring a clean layout. Here's the code for the implementation shown: import AVKit
import SwiftUI

struct VideoPlayerView: View {
    private var player = AVPlayer(url: URL(string: "https://www.example.com/samplevideo.mp4")!)

    var body: some View {
        VStack {
            VideoPlayer(player: player)
                .frame(height: 300)
                .cornerRadius(10)

            HStack {
                Button("Play Video") {
                    player.play()
                }
                .font(.headline)
                .foregroundColor(.white)
                .padding()
                .background(Color.blue)
                .cornerRadius(8)

                Button("Pause Video") {
                    player.pause()
                }
                .font(.headline)
                .foregroundColor(.white)
                .padding()
                .background(Color.red)
                .cornerRadius(8)
            }
            .padding(.top, 20)
        }
        .padding()
    }
}

struct ContentView: View {
    var body: some View {
        VStack {
            Text("Welcome to Video Player")
                .font(.largeTitle)
                .padding()

            VideoPlayerView()
        }
    }
} import AVKit
import SwiftUI

struct VideoPlayerView: View {
    private var player = AVPlayer(url: URL(string: "https://www.example.com/samplevideo.mp4")!)

    var body: some View {
        VStack {
            VideoPlayer(player: player)
                .frame(height: 300)
                .cornerRadius(10)

            HStack {
                Button("Play Video") {
                    player.play()
                }
                .font(.headline)
                .foregroundColor(.white)
                .padding()
                .background(Color.blue)
                .cornerRadius(8)

                Button("Pause Video") {
                    player.pause()
                }
                .font(.headline)
                .foregroundColor(.white)
                .padding()
                .background(Color.red)
                .cornerRadius(8)
            }
            .padding(.top, 20)
        }
        .padding()
    }
}

struct ContentView: View {
    var body: some View {
        VStack {
            Text("Welcome to Video Player")
                .font(.largeTitle)
                .padding()

            VideoPlayerView()
        }
    }
} The full series is available on my profile and the components can also be found at shipios.app/components . shipios.app/components shipios.app/components Happy Coding! 🎨 Happy Coding! 🎨

AVKit Integration in iOS 18 - #30DaysOfSwift

ARKit & LiDAR: Building Point Clouds in Swift (part 2)

Day 21: Custom Toggle Button, anyone? ⚙️ Today, we’re going to create a custom toggle button in SwiftUI. Implementing a Custom Toggle Button In this example, we’ll create a visually appealing custom toggle button that switches between on and off states. Code Example Here’s how you can implement a custom toggle button in SwiftUI: import SwiftUI

struct CustomToggle: View {
    @Binding var isOn: Bool // Binding variable for toggle state

        var body: some View {
            HStack {
                Text("Toggle Setting")
                    .foregroundColor(.primary) // Text color
                Spacer()
                // Custom square toggle design
                RoundedRectangle(cornerRadius: 5) // Rounded corners
                    .fill(isOn ? Color.blue : Color.gray) // Toggle color based on state
                    .frame(width: 60, height: 30) // Toggle size
                    .overlay(
                        Rectangle() // Square knob design
                            .fill(Color.white)
                            .frame(width: 26, height: 26)
                            .offset(x: isOn ? 15 : -15) // Move the square based on state
                            .animation(.easeInOut(duration: 0.2), value: isOn) // Animation for smooth transition
                    )
                    .onTapGesture {
                        isOn.toggle() // Toggle the state on tap
                    }
            }
            .padding() // Padding for the entire toggle
        }
    }

struct ContentView: View {
    @State private var isToggleOn = false // State to manage toggle status

    var body: some View {
        VStack {
            CustomToggle(isOn: $isToggleOn) // Custom toggle instance
            Text(isToggleOn ? "Setting is ON" : "Setting is OFF") // Display current state
                .padding()
        }
        .padding()
    }
}

@main
struct CustomToggleApp: App {
    var body: some Scene {
        WindowGroup {
            ContentView() // Main content view
        }
    
} The full series is available on my profile, and the components can also be found at shipios.app/components. Happy Coding! 🎈 Day 21: Custom Toggle Button, anyone? ⚙️ Day 21: Custom Toggle Button, anyone? ⚙️ Today, we’re going to create a custom toggle button in SwiftUI. custom toggle button Implementing a Custom Toggle Button In this example, we’ll create a visually appealing custom toggle button that switches between on and off states. Code Example Here’s how you can implement a custom toggle button in SwiftUI: import SwiftUI

struct CustomToggle: View {
    @Binding var isOn: Bool // Binding variable for toggle state

        var body: some View {
            HStack {
                Text("Toggle Setting")
                    .foregroundColor(.primary) // Text color
                Spacer()
                // Custom square toggle design
                RoundedRectangle(cornerRadius: 5) // Rounded corners
                    .fill(isOn ? Color.blue : Color.gray) // Toggle color based on state
                    .frame(width: 60, height: 30) // Toggle size
                    .overlay(
                        Rectangle() // Square knob design
                            .fill(Color.white)
                            .frame(width: 26, height: 26)
                            .offset(x: isOn ? 15 : -15) // Move the square based on state
                            .animation(.easeInOut(duration: 0.2), value: isOn) // Animation for smooth transition
                    )
                    .onTapGesture {
                        isOn.toggle() // Toggle the state on tap
                    }
            }
            .padding() // Padding for the entire toggle
        }
    }

struct ContentView: View {
    @State private var isToggleOn = false // State to manage toggle status

    var body: some View {
        VStack {
            CustomToggle(isOn: $isToggleOn) // Custom toggle instance
            Text(isToggleOn ? "Setting is ON" : "Setting is OFF") // Display current state
                .padding()
        }
        .padding()
    }
}

@main
struct CustomToggleApp: App {
    var body: some Scene {
        WindowGroup {
            ContentView() // Main content view
        }
    
} import SwiftUI

struct CustomToggle: View {
    @Binding var isOn: Bool // Binding variable for toggle state

        var body: some View {
            HStack {
                Text("Toggle Setting")
                    .foregroundColor(.primary) // Text color
                Spacer()
                // Custom square toggle design
                RoundedRectangle(cornerRadius: 5) // Rounded corners
                    .fill(isOn ? Color.blue : Color.gray) // Toggle color based on state
                    .frame(width: 60, height: 30) // Toggle size
                    .overlay(
                        Rectangle() // Square knob design
                            .fill(Color.white)
                            .frame(width: 26, height: 26)
                            .offset(x: isOn ? 15 : -15) // Move the square based on state
                            .animation(.easeInOut(duration: 0.2), value: isOn) // Animation for smooth transition
                    )
                    .onTapGesture {
                        isOn.toggle() // Toggle the state on tap
                    }
            }
            .padding() // Padding for the entire toggle
        }
    }

struct ContentView: View {
    @State private var isToggleOn = false // State to manage toggle status

    var body: some View {
        VStack {
            CustomToggle(isOn: $isToggleOn) // Custom toggle instance
            Text(isToggleOn ? "Setting is ON" : "Setting is OFF") // Display current state
                .padding()
        }
        .padding()
    }
}

@main
struct CustomToggleApp: App {
    var body: some Scene {
        WindowGroup {
            ContentView() // Main content view
        }
    
} The full series is available on my profile, and the components can also be found at shipios.app/components . shipios.app/components shipios.app/components Happy Coding! 🎈

How to Create a Custom Toggle Button in iOS 18 - #30DaysOfSwift

Day 14: Enhancing Interactions with Context ⚙️ Welcome back to the #30DaysOfSwift series! Today, let's look at Context Menus. A powerful way to offer additional actions when users long-press or right-click on UI elements. By integrating context menus into your SwiftUI app, you can create a smooth, intuitive experience for users when interacting with different elements. What are Context Menus? Context Menus provide additional actions that a user can perform on an element. They are revealed via a long press or right-click, making it easy for users to access additional options without cluttering the UI. Code Example: Context Menus in Action struct ContextMenuExample: View {
    @State private var favorite: Bool = false

    var body: some View {
        VStack {
            HStack {
                Text("Long-press me!")
                    .font(.title2)
                    .padding()
                Spacer()
                if favorite {
                    Image(systemName: "heart.fill")
                        .foregroundColor(.red) // Customization: Heart icon if marked as favorite
                }
            }
            .frame(maxWidth: .infinity)
            .padding()
            .background(Color.blue.opacity(0.2)) // Custom background color
            .cornerRadius(10) // Rounded corners for aesthetic touch
            .contextMenu { // Adding the context menu
                Button(action: {
                    favorite.toggle()
                }) {
                    Label("Favorite", systemImage: favorite ? "heart.fill" : "heart")
                }

                Button(action: {
                    print("Shared!")
                }) {
                    Label("Share", systemImage: "square.and.arrow.up")
                }

                Button(action: {
                    print("Deleted!")
                }) {
                    Label("Delete", systemImage: "trash")
                        .foregroundColor(.red) // Custom color for danger actions
                }
            }
        }
        .padding()
    }
} Now, it's your turn! Try adding context menus to elements in your app to make your interactions more intuitive and user-friendly! The full series is available on my profile, and the components can also be found at shipios.app/components. Happy Coding! 🎨 Day 14: Enhancing Interactions with Context ⚙️ Day 14: Enhancing Interactions with Context Welcome back to the #30DaysOfSwift series! Today, let's look at Context Menus. A powerful way to offer additional actions when users long-press or right-click on UI elements. By integrating context menus into your SwiftUI app, you can create a smooth, intuitive experience for users when interacting with different elements. What are Context Menus? Context Menus provide additional actions that a user can perform on an element. Context Menus provide additional actions that a user can perform on an element. They are revealed via a long press or right-click, making it easy for users to access additional options without cluttering the UI. They are revealed via a long press or right-click, making it easy for users to access additional options without cluttering the UI. Code Example: Context Menus in Action Code Example: Context Menus in Action struct ContextMenuExample: View {
    @State private var favorite: Bool = false

    var body: some View {
        VStack {
            HStack {
                Text("Long-press me!")
                    .font(.title2)
                    .padding()
                Spacer()
                if favorite {
                    Image(systemName: "heart.fill")
                        .foregroundColor(.red) // Customization: Heart icon if marked as favorite
                }
            }
            .frame(maxWidth: .infinity)
            .padding()
            .background(Color.blue.opacity(0.2)) // Custom background color
            .cornerRadius(10) // Rounded corners for aesthetic touch
            .contextMenu { // Adding the context menu
                Button(action: {
                    favorite.toggle()
                }) {
                    Label("Favorite", systemImage: favorite ? "heart.fill" : "heart")
                }

                Button(action: {
                    print("Shared!")
                }) {
                    Label("Share", systemImage: "square.and.arrow.up")
                }

                Button(action: {
                    print("Deleted!")
                }) {
                    Label("Delete", systemImage: "trash")
                        .foregroundColor(.red) // Custom color for danger actions
                }
            }
        }
        .padding()
    }
} struct ContextMenuExample: View {
    @State private var favorite: Bool = false

    var body: some View {
        VStack {
            HStack {
                Text("Long-press me!")
                    .font(.title2)
                    .padding()
                Spacer()
                if favorite {
                    Image(systemName: "heart.fill")
                        .foregroundColor(.red) // Customization: Heart icon if marked as favorite
                }
            }
            .frame(maxWidth: .infinity)
            .padding()
            .background(Color.blue.opacity(0.2)) // Custom background color
            .cornerRadius(10) // Rounded corners for aesthetic touch
            .contextMenu { // Adding the context menu
                Button(action: {
                    favorite.toggle()
                }) {
                    Label("Favorite", systemImage: favorite ? "heart.fill" : "heart")
                }

                Button(action: {
                    print("Shared!")
                }) {
                    Label("Share", systemImage: "square.and.arrow.up")
                }

                Button(action: {
                    print("Deleted!")
                }) {
                    Label("Delete", systemImage: "trash")
                        .foregroundColor(.red) // Custom color for danger actions
                }
            }
        }
        .padding()
    }
} Now, it's your turn! Try adding context menus to elements in your app to make your interactions more intuitive and user-friendly! The full series is available on my profile, and the components can also be found at shipios.app/components . shipios.app/components shipios.app/components Happy Coding! 🎨 Happy Coding!

Context Menus in iOS 18 - #30DaysOfSwift

Day 13: LazyVStack vs List – Efficient List Building in SwiftUI 🛠️ In today's post of the #30DaysOfSwift series, we’re diving into the two essential components for building lists in SwiftUI. While both are great for displaying large amounts of content, they have distinct use cases and performance differences. Key Differences: LazyVStack: Offers a flexible, customizable layout for stacking views vertically. Loads content lazily as it comes into view, improving performance for large datasets. Provides more control over the design, allowing customization beyond what List offers. List: Designed for basic, standard lists with built-in functionality like separators, row editing, and reordering. Ideal for quick, out-of-the-box list implementations. Provides automatic lazy loading but less flexibility for custom UI. Code Example: Using LazyVStack vs List We'll build the same list using both LazyVStack and List to see how they compare in terms of flexibility and performance. LazyVStack Example: import SwiftUI

struct LazyVStackExample: View {
    let items = Array(1...100) // Sample data for list

    var body: some View {
        ScrollView {
            LazyVStack(spacing: 20) { // LazyVStack to load views lazily
                ForEach(items, id: \.self) { item in
                    HStack {
                        Text("Item \(item)")
                            .font(.headline)
                        Spacer()
                    }
                    .padding()
                    .background(Color.blue.opacity(0.1))
                    .cornerRadius(10) // Customization with rounded corners
                }
            }
            .padding()
        }
    }
} List Example: import SwiftUI

struct ListExample: View {
    let items = Array(1...100) // Sample data for list

    var body: some View {
        List(items, id: \.self) { item in
            HStack {
                Text("Item \(item)")
                    .font(.headline)
                Spacer()
            }
        }
        .listStyle(PlainListStyle()) // Using PlainListStyle for a simpler look
    }
} When to Use: LazyVStack: Use when you need full control over the layout or when you have a complex, customized UI. Best suited for building dynamic layouts, like scrollable cards or grids. List: Use for quick, standard lists like settings menus, simple item lists, or when you need built-in row management (e.g., swipe-to-delete). Best when you need simplicity without too much custom styling. Now that you’ve seen both approaches, choose the one that fits your app's design and performance needs! The full series is available on my profile, and the components can also be found at shipios.app/components. Happy Coding! 🌟 Day 13: LazyVStack vs List – Efficient List Building in SwiftUI 🛠️ Day 13: LazyVStack vs List – Efficient List Building in SwiftUI In today's post of the #30DaysOfSwift series, we’re diving into the two essential components for building lists in SwiftUI. While both are great for displaying large amounts of content, they have distinct use cases and performance differences. Key Differences: LazyVStack: LazyVStack: Offers a flexible, customizable layout for stacking views vertically. Offers a flexible, customizable layout for stacking views vertically. Loads content lazily as it comes into view, improving performance for large datasets. Loads content lazily as it comes into view, improving performance for large datasets. Provides more control over the design, allowing customization beyond what List offers. Provides more control over the design, allowing customization beyond what List offers. List: List: Designed for basic, standard lists with built-in functionality like separators, row editing, and reordering. Designed for basic, standard lists with built-in functionality like separators, row editing, and reordering. Ideal for quick, out-of-the-box list implementations. Ideal for quick, out-of-the-box list implementations. Provides automatic lazy loading but less flexibility for custom UI. Provides automatic lazy loading but less flexibility for custom UI. Code Example: Using LazyVStack vs List Code Example: Using LazyVStack vs List We'll build the same list using both LazyVStack and List to see how they compare in terms of flexibility and performance. LazyVStack Example: import SwiftUI

struct LazyVStackExample: View {
    let items = Array(1...100) // Sample data for list

    var body: some View {
        ScrollView {
            LazyVStack(spacing: 20) { // LazyVStack to load views lazily
                ForEach(items, id: \.self) { item in
                    HStack {
                        Text("Item \(item)")
                            .font(.headline)
                        Spacer()
                    }
                    .padding()
                    .background(Color.blue.opacity(0.1))
                    .cornerRadius(10) // Customization with rounded corners
                }
            }
            .padding()
        }
    }
} import SwiftUI

struct LazyVStackExample: View {
    let items = Array(1...100) // Sample data for list

    var body: some View {
        ScrollView {
            LazyVStack(spacing: 20) { // LazyVStack to load views lazily
                ForEach(items, id: \.self) { item in
                    HStack {
                        Text("Item \(item)")
                            .font(.headline)
                        Spacer()
                    }
                    .padding()
                    .background(Color.blue.opacity(0.1))
                    .cornerRadius(10) // Customization with rounded corners
                }
            }
            .padding()
        }
    }
} List Example: List Example: import SwiftUI

struct ListExample: View {
    let items = Array(1...100) // Sample data for list

    var body: some View {
        List(items, id: \.self) { item in
            HStack {
                Text("Item \(item)")
                    .font(.headline)
                Spacer()
            }
        }
        .listStyle(PlainListStyle()) // Using PlainListStyle for a simpler look
    }
} import SwiftUI

struct ListExample: View {
    let items = Array(1...100) // Sample data for list

    var body: some View {
        List(items, id: \.self) { item in
            HStack {
                Text("Item \(item)")
                    .font(.headline)
                Spacer()
            }
        }
        .listStyle(PlainListStyle()) // Using PlainListStyle for a simpler look
    }
} When to Use: LazyVStack: LazyVStack: Use when you need full control over the layout or when you have a complex, customized UI. Use when you need full control over the layout or when you have a complex, customized UI. Best suited for building dynamic layouts, like scrollable cards or grids. Best suited for building dynamic layouts, like scrollable cards or grids. List: List: Use for quick, standard lists like settings menus, simple item lists, or when you need built-in row management (e.g., swipe-to-delete). Use for quick, standard lists like settings menus, simple item lists, or when you need built-in row management (e.g., swipe-to-delete). Best when you need simplicity without too much custom styling. Best when you need simplicity without too much custom styling. Now that you’ve seen both approaches, choose the one that fits your app's design and performance needs! The full series is available on my profile, and the components can also be found at shipios.app/components. Happy Coding! 🌟 Happy Coding!

Stories, News & Mentions about HOPSTACK

Hopstack’s Stories on HackerNoon