Privacy

1DEFAULT_FILE_STORAGE = 'storages.backends.sftpstorage.SFTPStorage'
2SFTP_STORAGE_HOST = 'username.your-storagebox.de'
3SFTP_STORAGE_ROOT = '/media'
4
5SFTP_STORAGE_PARAMS = {
6'username': 'username',
7'password': 'password',
8'allow_agent': False,
9'look_for_keys': False,
10}
11[03/Sep/2021 22:34:01] "GET /media/filename.jpg HTTP/1.1" 404 1962
12MEDIA_DIR = 'media'
13MEDIA_ROOT = os.path.join(BASE_DIR, MEDIA_DIR)
14MEDIA_URL = '/media/'
15class SizeRestrictedImageField(ImageField):
16
17    def __init__(self, *args, **kwargs):
18        self.max_upload_size = kwargs.pop('max_upload_size', 0)
19        super().__init__(*args, **kwargs)
20
21    def clean(self, *args, **kwargs):
22        data = super().clean(*args, **kwargs)
23
24        file = data.file
25        try:
26            if file.size > self.max_upload_size:
27                raise forms.ValidationError(_('Please keep filesize under %s. Current filesize %s'
28                        ) % (filesizeformat(self.max_upload_size),
29                        filesizeformat(file.size)))
30        except AttributeError:
31            logger.exception('An Exception occured while checking for max size of image upload. size: `%s`'
32                             , file.size)
33            pass
34
35        return data
36
37
38class ImageModel(models.Model):
39    image = SizeRestrictedImageField(upload_to=POST_PIC_FOLDER, null=True, blank=True,
40                              help_text="Erlaubte Dateitypen: .jpeg, .jpg, .png, .gif", max_upload_size=MAX_IMAGE_SIZE)
41urlpatterns = [
42                  path('defaultsite/', defaultsite_view, name='home'),
43                  path('help', help_view, name="help"),
44                  path('user/', include('user.urls')),
45                  path('sowi/', include('sowi.urls')),
46                  path('blog/', include('blog.urls')),
47                  path('chat/', include('chat.urls')),
48                  path('notifications/', include('notifications.urls')),
49                  path('cookies/', include('cookie_consent.urls')),
50                  path('', home_view, name="home"),
51                  path('about/', AboutUsView.as_view(), name="about-us"),
52                  path('impressum/', impressum_view, name="imprint"),
53                  path('privacy/', privacy_view, name='privacy'),
54                  path('privacy/statement/', privacy_statement_view, name='privacy-statement'),
55                  path('agb', agb_view, name="agb")
56              ] + static(settings.STATIC_URL, document_root=settings.STATIC_ROOT) + static(settings.MEDIA_URL,
57                                                                                           document_root=settings.MEDIA_ROOT)
58photo = models.FileField(
59    storage=FileSystemStorage(location=settings.MEDIA_ROOT),
60    upload_to='photos',
61)
62

1DEFAULT_FILE_STORAGE = 'storages.backends.sftpstorage.SFTPStorage'
2SFTP_STORAGE_HOST = 'username.your-storagebox.de'
3SFTP_STORAGE_ROOT = '/media'
4
5SFTP_STORAGE_PARAMS = {
6'username': 'username',
7'password': 'password',
8'allow_agent': False,
9'look_for_keys': False,
10}
11[03/Sep/2021 22:34:01] "GET /media/filename.jpg HTTP/1.1" 404 1962
12MEDIA_DIR = 'media'
13MEDIA_ROOT = os.path.join(BASE_DIR, MEDIA_DIR)
14MEDIA_URL = '/media/'
15class SizeRestrictedImageField(ImageField):
16
17    def __init__(self, *args, **kwargs):
18        self.max_upload_size = kwargs.pop('max_upload_size', 0)
19        super().__init__(*args, **kwargs)
20
21    def clean(self, *args, **kwargs):
22        data = super().clean(*args, **kwargs)
23
24        file = data.file
25        try:
26            if file.size > self.max_upload_size:
27                raise forms.ValidationError(_('Please keep filesize under %s. Current filesize %s'
28                        ) % (filesizeformat(self.max_upload_size),
29                        filesizeformat(file.size)))
30        except AttributeError:
31            logger.exception('An Exception occured while checking for max size of image upload. size: `%s`'
32                             , file.size)
33            pass
34
35        return data
36
37
38class ImageModel(models.Model):
39    image = SizeRestrictedImageField(upload_to=POST_PIC_FOLDER, null=True, blank=True,
40                              help_text="Erlaubte Dateitypen: .jpeg, .jpg, .png, .gif", max_upload_size=MAX_IMAGE_SIZE)
41urlpatterns = [
42                  path('defaultsite/', defaultsite_view, name='home'),
43                  path('help', help_view, name="help"),
44                  path('user/', include('user.urls')),
45                  path('sowi/', include('sowi.urls')),
46                  path('blog/', include('blog.urls')),
47                  path('chat/', include('chat.urls')),
48                  path('notifications/', include('notifications.urls')),
49                  path('cookies/', include('cookie_consent.urls')),
50                  path('', home_view, name="home"),
51                  path('about/', AboutUsView.as_view(), name="about-us"),
52                  path('impressum/', impressum_view, name="imprint"),
53                  path('privacy/', privacy_view, name='privacy'),
54                  path('privacy/statement/', privacy_statement_view, name='privacy-statement'),
55                  path('agb', agb_view, name="agb")
56              ] + static(settings.STATIC_URL, document_root=settings.STATIC_ROOT) + static(settings.MEDIA_URL,
57                                                                                           document_root=settings.MEDIA_ROOT)
58photo = models.FileField(
59    storage=FileSystemStorage(location=settings.MEDIA_ROOT),
60    upload_to='photos',
61)
62photo = models.FileField(
63    upload_to='photos',
64)
65

1DEFAULT_FILE_STORAGE = 'storages.backends.sftpstorage.SFTPStorage'
2SFTP_STORAGE_HOST = 'username.your-storagebox.de'
3SFTP_STORAGE_ROOT = '/media'
4
5SFTP_STORAGE_PARAMS = {
6'username': 'username',
7'password': 'password',
8'allow_agent': False,
9'look_for_keys': False,
10}
11[03/Sep/2021 22:34:01] "GET /media/filename.jpg HTTP/1.1" 404 1962
12MEDIA_DIR = 'media'
13MEDIA_ROOT = os.path.join(BASE_DIR, MEDIA_DIR)
14MEDIA_URL = '/media/'
15class SizeRestrictedImageField(ImageField):
16
17    def __init__(self, *args, **kwargs):
18        self.max_upload_size = kwargs.pop('max_upload_size', 0)
19        super().__init__(*args, **kwargs)
20
21    def clean(self, *args, **kwargs):
22        data = super().clean(*args, **kwargs)
23
24        file = data.file
25        try:
26            if file.size > self.max_upload_size:
27                raise forms.ValidationError(_('Please keep filesize under %s. Current filesize %s'
28                        ) % (filesizeformat(self.max_upload_size),
29                        filesizeformat(file.size)))
30        except AttributeError:
31            logger.exception('An Exception occured while checking for max size of image upload. size: `%s`'
32                             , file.size)
33            pass
34
35        return data
36
37
38class ImageModel(models.Model):
39    image = SizeRestrictedImageField(upload_to=POST_PIC_FOLDER, null=True, blank=True,
40                              help_text="Erlaubte Dateitypen: .jpeg, .jpg, .png, .gif", max_upload_size=MAX_IMAGE_SIZE)
41urlpatterns = [
42                  path('defaultsite/', defaultsite_view, name='home'),
43                  path('help', help_view, name="help"),
44                  path('user/', include('user.urls')),
45                  path('sowi/', include('sowi.urls')),
46                  path('blog/', include('blog.urls')),
47                  path('chat/', include('chat.urls')),
48                  path('notifications/', include('notifications.urls')),
49                  path('cookies/', include('cookie_consent.urls')),
50                  path('', home_view, name="home"),
51                  path('about/', AboutUsView.as_view(), name="about-us"),
52                  path('impressum/', impressum_view, name="imprint"),
53                  path('privacy/', privacy_view, name='privacy'),
54                  path('privacy/statement/', privacy_statement_view, name='privacy-statement'),
55                  path('agb', agb_view, name="agb")
56              ] + static(settings.STATIC_URL, document_root=settings.STATIC_ROOT) + static(settings.MEDIA_URL,
57                                                                                           document_root=settings.MEDIA_ROOT)
58photo = models.FileField(
59    storage=FileSystemStorage(location=settings.MEDIA_ROOT),
60    upload_to='photos',
61)
62photo = models.FileField(
63    upload_to='photos',
64)
65@action(methods=['get'], detail=True)
66def download(self, request, pk=None):
67
68    try:
69        obj = ImageModel.objects.get(id=pk)
70    except ImageModel.DoesNotExist:
71        raise Http404
72
73    # with some SFTP client
74    # 1. check the file exist
75    # 2. pull the file from the server
76    # 3. attach it to the response with the proper header
77    stream = sftp_client.open(obj.file.name)
78    file = stream.read()
79
80    type, encoding = mimetypes.guess_type(obj.file.name)
81    response = HttpResponse(file, content_type=type)
82    response['Content-Disposition'] = u'attachment; filename="{filename}'.format(
83            filename=obj.file.name)
84        return response
85    raise Http404
86

1enum Privacy: String, Identifiable, CaseIterable {
2    case open = "Open"
3    case closed = "Closed"
4    var id: String { self.rawValue }
5}
6
7struct ContentView: View {
8    @State var selection = Privacy.open
9    var body: some View {
10        Picker("Privacy", selection: $selection) {
11            ForEach(Privacy.allCases) { value in
12                Text(value.rawValue)
13                    .tag(value)
14                    .font(.largeTitle)
15            }
16        }
17        .font(.largeTitle)
18        .pickerStyle(.menu)
19    }
20}
21Menu {
22    Picker(selection: $selection) {
23        ForEach(Privacy.allCases) { value in
24            Text(value.rawValue)
25                .tag(value)
26                .font(.largeTitle)
27        }
28    } label: {}
29} label: {
30    Text("Privacy")
31        .font(.largeTitle)
32}
33

1<uses-permission android:name="com.google.android.gms.permission.AD_ID"/>
2

1await user.dm_channel.send("Hello there")
2discord.errors.Forbidden: 403 Forbidden (error code: 50007): Cannot send messages to this user
3print(user.dm_channel.permissions_for(bot).send_messages)
4channel = await user.create_dm()
5if channel is None:
6    ...
7!newgame @DJMcMayhem @Steve
8> I can't start a game with that list of users because @Steve has the wrong privacy settings.
9async def can_dm_user(user: discord.User) -> bool:
10    ch = user.dm_channel
11    if ch is None:
12        ch = await user.create_dm()
13
14    try:
15        await ch.send()
16    except discord.Forbidden:
17        return False
18    except discord.HTTPException:
19        return True
20
21

1import SwiftUI
2import UniformTypeIdentifiers
3import Alamofire
4
5struct ContentView: View {
6    @AppStorage("downloadsDirectory") var downloadsDirectory = ""
7    
8    @State private var showFileImporter = false
9    
10    var body: some View {
11        VStack {
12            Button("Set downloads directory") {
13                showFileImporter.toggle()
14            }
15            
16            Button("Save to downloads directory") {
17                Task {
18                    do {
19                        let destination: DownloadRequest.Destination = { _, response in
20                            let documentsURL = URL(string: downloadsDirectory)!
21                            let suggestedName = response.suggestedFilename ?? "unknown"
22
23                            let fileURL = documentsURL.appendingPathComponent(suggestedName)
24
25                            return (fileURL, [.removePreviousFile, .createIntermediateDirectories])
26                        }
27
28                        let _ = try await AF.download(URL(string: "https://i.imgur.com/zaVQDFJ.png")!, to: destination).serializingDownloadedFileURL().value
29                    } catch {
30                        print("Downloading error!: \(error)")
31                    }
32                }
33            }
34        }
35        .fileImporter(isPresented: $showFileImporter, allowedContentTypes: [UTType.folder]) { result in
36            switch result {
37            case .success(let url):
38                downloadsDirectory = url.absoluteString
39            case .failure(let error):
40                print("Download picker error: \(error)")
41            }
42        }
43    }
44}
45<key>NSDocumentsFolderUsageDescription</key>
46<string>App wants to access your documents folder</string>
47<key>NSDownloadsFolderUsageDescription</key>
48<string>App wants to access your downloads folder</string>
49<key>LSSupportsOpeningDocumentsInPlace</key>
50<true/>
51<key>UIFileSharingEnabled</key>
52<true/>
53import SwiftUI
54import UniformTypeIdentifiers
55import Alamofire
56
57struct ContentView: View {
58    @AppStorage("bookmarkData") var downloadsBookmark: Data?
59    
60    @State private var showFileImporter = false
61    
62    var body: some View {
63        VStack {
64            Button("Set downloads directory") {
65                showFileImporter.toggle()
66            }
67            
68            Button("Save to downloads directory") {
69                Task {
70                    do {
71                        let destination: DownloadRequest.Destination = { _, response in
72                            // Save to a temp directory in app documents
73                            let documentsURL = FileManager.default.urls(for: .documentDirectory, in: .userDomainMask)[0].appendingPathComponent("Downloads")
74                            let suggestedName = response.suggestedFilename ?? "unknown"
75
76                            let fileURL = documentsURL.appendingPathComponent(suggestedName)
77
78                            return (fileURL, [.removePreviousFile, .createIntermediateDirectories])
79                        }
80
81                        let tempUrl = try await AF.download(URL(string: "https://i.imgur.com/zaVQDFJ.png")!, to: destination).serializingDownloadedFileURL().value
82                        
83                        // Get the bookmark data from the AppStorage call
84                        guard let bookmarkData = downloadsBookmark else {
85                            return
86                        }
87                        var isStale = false
88                        let downloadsUrl = try URL(resolvingBookmarkData: bookmarkData, bookmarkDataIsStale: &isStale)
89                        
90                        guard !isStale else {
91                            // Log that the bookmark is stale
92                            
93                            return
94                        }
95                        
96                        // Securely access the URL from the bookmark data
97                        guard downloadsUrl.startAccessingSecurityScopedResource() else {
98                            print("Can't access security scoped resource")
99                            
100                            return
101                        }
102                        
103                        // We have to stop accessing the resource no matter what
104                        defer { downloadsUrl.stopAccessingSecurityScopedResource() }
105                        
106                        do {
107                            try FileManager.default.moveItem(at: tempUrl, to: downloadsUrl.appendingPathComponent(tempUrl.lastPathComponent))
108                        } catch {
109                            print("Move error: \(error)")
110                        }
111                    } catch {
112                        print("Downloading error!: \(error)")
113                    }
114                }
115            }
116        }
117        .fileImporter(isPresented: $showFileImporter, allowedContentTypes: [UTType.folder]) { result in
118            switch result {
119            case .success(let url):
120                // Securely access the URL to save a bookmark
121                guard url.startAccessingSecurityScopedResource() else {
122                    // Handle the failure here.
123                    return
124                }
125                
126                // We have to stop accessing the resource no matter what
127                defer { url.stopAccessingSecurityScopedResource() }
128                
129                do {
130                    // Make sure the bookmark is minimal!
131                    downloadsBookmark = try url.bookmarkData(options: .minimalBookmark, includingResourceValuesForKeys: nil, relativeTo: nil)
132                } catch {
133                    print("Bookmark error \(error)")
134                }
135            case .failure(let error):
136                print("Importer error: \(error)")
137            }
138        }
139    }
140}
141

1func send(_ data: Data, toPeers peerIDs: [MCPeerID], with mode: MCSessionSendDataMode)
2

1func send(_ data: Data, toPeers peerIDs: [MCPeerID], with mode: MCSessionSendDataMode)
2func session(_ session: MCSession, 
3             didFinishReceivingResourceWithName resourceName: String, 
4             fromPeer peerID: MCPeerID, 
5             at localURL: URL?, 
6             withError error: Error?)
7

1func send(_ data: Data, toPeers peerIDs: [MCPeerID], with mode: MCSessionSendDataMode)
2func session(_ session: MCSession, 
3             didFinishReceivingResourceWithName resourceName: String, 
4             fromPeer peerID: MCPeerID, 
5             at localURL: URL?, 
6             withError error: Error?)
7func startStream(withName streamName: String, 
8                 toPeer peerID: MCPeerID) throws -> OutputStream
9

1func send(_ data: Data, toPeers peerIDs: [MCPeerID], with mode: MCSessionSendDataMode)
2func session(_ session: MCSession, 
3             didFinishReceivingResourceWithName resourceName: String, 
4             fromPeer peerID: MCPeerID, 
5             at localURL: URL?, 
6             withError error: Error?)
7func startStream(withName streamName: String, 
8                 toPeer peerID: MCPeerID) throws -> OutputStream
9// Progress variable that needs to store the progress of the file transfer
10var fileTransferProgress: Progress?
11    
12// Timer that will be used to check the file transfer progress
13var checkProgressTimer: Timer?
14
15// Used by the host to track bytes to receive
16var bytesExpectedToExchange = 0
17    
18// Used to track the time taken in transfer, this is for testing purposes.
19// You might get more reliable results using Date to track time
20var transferTimeElapsed = 0.0
21

1func send(_ data: Data, toPeers peerIDs: [MCPeerID], with mode: MCSessionSendDataMode)
2func session(_ session: MCSession, 
3             didFinishReceivingResourceWithName resourceName: String, 
4             fromPeer peerID: MCPeerID, 
5             at localURL: URL?, 
6             withError error: Error?)
7func startStream(withName streamName: String, 
8                 toPeer peerID: MCPeerID) throws -> OutputStream
9// Progress variable that needs to store the progress of the file transfer
10var fileTransferProgress: Progress?
11    
12// Timer that will be used to check the file transfer progress
13var checkProgressTimer: Timer?
14
15// Used by the host to track bytes to receive
16var bytesExpectedToExchange = 0
17    
18// Used to track the time taken in transfer, this is for testing purposes.
19// You might get more reliable results using Date to track time
20var transferTimeElapsed = 0.0
21// A new action added to send the image stored in the bundle
22@IBAction func sendImageAsResource(_ sender: Any) 
23{        
24        // Call local function created
25        sendImageAsResource()
26}
27
28func sendImageAsResource()
29{
30        // 1. Get the url of the image in the project bundle.
31        // Change this if your image is hosted in your documents directory
32        // or elsewhere.
33        //
34        // 2. Get all the connected peers. For testing purposes I am only
35        // getting the first peer, you might need to loop through all your
36        // connected peers and send the files individually.
37        guard let imageURL = Bundle.main.url(forResource: "image2",
38                                             withExtension: "jpg"),
39              let guestPeerID = mcSession.connectedPeers.first else {
40            return
41        }
42        
43        // Retrieve the file size of the image
44        if let fileSizeToTransfer = getFileSize(atURL: imageURL)
45        {
46            bytesExpectedToExchange = fileSizeToTransfer
47            
48            // Put the file size in a dictionary
49            let fileTransferMeta = ["fileSize": bytesExpectedToExchange]
50            
51            // Convert the dictionary to a data object in order to send it via
52            // MultiPeer
53            let encoder = JSONEncoder()
54            
55            if let JSONData = try? encoder.encode(fileTransferMeta)
56            {
57                // Send the file size to the guest users
58                try? mcSession.send(JSONData, toPeers: mcSession.connectedPeers,
59                                    with: .reliable)
60            }
61        }
62        
63        // Ideally for best reliability, you will want to develop some logic
64        // for the guest to respond that it has received the file size and then
65        // you should initiate the transfer to that peer only after you receive
66        // this confirmation. For now, I just add a delay so that I am highly
67        // certain the guest has received this data for testing purposes
68        DispatchQueue.main.asyncAfter(deadline: .now() + 1)
69        { [weak self] in
70            self?.initiateFileTransfer(ofImage: imageURL, to: guestPeerID)
71        }
72    }
73    
74func initiateFileTransfer(ofImage imageURL: URL, to guestPeerID: MCPeerID)
75{
76        // Initialize and fire a timer to check the status of the file
77        // transfer every 0.1 second
78        checkProgressTimer = Timer.scheduledTimer(timeInterval: 0.1,
79                                                  target: self,
80                                                  selector: #selector(updateProgressStatus),
81                                                  userInfo: nil,
82                                                  repeats: true)
83        
84        // Call the sendResource function and send the image from the bundle
85        // keeping hold of the returned progress object which we need to keep checking
86        // using the timer
87        fileTransferProgress = mcSession.sendResource(at: imageURL,
88                                          withName: "image2.jpg",
89                                          toPeer: guestPeerID,
90                                          withCompletionHandler: { (error) in
91                                            
92                                            // Handle errors
93                                            if let error = error as NSError?
94                                            {
95                                                print("Error: \(error.userInfo)")
96                                                print("Error: \(error.localizedDescription)")
97                                            }
98                                            
99                                          })
100}
101
102func getFileSize(atURL url: URL) -> Int?
103{
104        let urlResourceValue = try? url.resourceValues(forKeys: [.fileSizeKey])
105        
106        return urlResourceValue?.fileSize
107}
108

1func send(_ data: Data, toPeers peerIDs: [MCPeerID], with mode: MCSessionSendDataMode)
2func session(_ session: MCSession, 
3             didFinishReceivingResourceWithName resourceName: String, 
4             fromPeer peerID: MCPeerID, 
5             at localURL: URL?, 
6             withError error: Error?)
7func startStream(withName streamName: String, 
8                 toPeer peerID: MCPeerID) throws -> OutputStream
9// Progress variable that needs to store the progress of the file transfer
10var fileTransferProgress: Progress?
11    
12// Timer that will be used to check the file transfer progress
13var checkProgressTimer: Timer?
14
15// Used by the host to track bytes to receive
16var bytesExpectedToExchange = 0
17    
18// Used to track the time taken in transfer, this is for testing purposes.
19// You might get more reliable results using Date to track time
20var transferTimeElapsed = 0.0
21// A new action added to send the image stored in the bundle
22@IBAction func sendImageAsResource(_ sender: Any) 
23{        
24        // Call local function created
25        sendImageAsResource()
26}
27
28func sendImageAsResource()
29{
30        // 1. Get the url of the image in the project bundle.
31        // Change this if your image is hosted in your documents directory
32        // or elsewhere.
33        //
34        // 2. Get all the connected peers. For testing purposes I am only
35        // getting the first peer, you might need to loop through all your
36        // connected peers and send the files individually.
37        guard let imageURL = Bundle.main.url(forResource: "image2",
38                                             withExtension: "jpg"),
39              let guestPeerID = mcSession.connectedPeers.first else {
40            return
41        }
42        
43        // Retrieve the file size of the image
44        if let fileSizeToTransfer = getFileSize(atURL: imageURL)
45        {
46            bytesExpectedToExchange = fileSizeToTransfer
47            
48            // Put the file size in a dictionary
49            let fileTransferMeta = ["fileSize": bytesExpectedToExchange]
50            
51            // Convert the dictionary to a data object in order to send it via
52            // MultiPeer
53            let encoder = JSONEncoder()
54            
55            if let JSONData = try? encoder.encode(fileTransferMeta)
56            {
57                // Send the file size to the guest users
58                try? mcSession.send(JSONData, toPeers: mcSession.connectedPeers,
59                                    with: .reliable)
60            }
61        }
62        
63        // Ideally for best reliability, you will want to develop some logic
64        // for the guest to respond that it has received the file size and then
65        // you should initiate the transfer to that peer only after you receive
66        // this confirmation. For now, I just add a delay so that I am highly
67        // certain the guest has received this data for testing purposes
68        DispatchQueue.main.asyncAfter(deadline: .now() + 1)
69        { [weak self] in
70            self?.initiateFileTransfer(ofImage: imageURL, to: guestPeerID)
71        }
72    }
73    
74func initiateFileTransfer(ofImage imageURL: URL, to guestPeerID: MCPeerID)
75{
76        // Initialize and fire a timer to check the status of the file
77        // transfer every 0.1 second
78        checkProgressTimer = Timer.scheduledTimer(timeInterval: 0.1,
79                                                  target: self,
80                                                  selector: #selector(updateProgressStatus),
81                                                  userInfo: nil,
82                                                  repeats: true)
83        
84        // Call the sendResource function and send the image from the bundle
85        // keeping hold of the returned progress object which we need to keep checking
86        // using the timer
87        fileTransferProgress = mcSession.sendResource(at: imageURL,
88                                          withName: "image2.jpg",
89                                          toPeer: guestPeerID,
90                                          withCompletionHandler: { (error) in
91                                            
92                                            // Handle errors
93                                            if let error = error as NSError?
94                                            {
95                                                print("Error: \(error.userInfo)")
96                                                print("Error: \(error.localizedDescription)")
97                                            }
98                                            
99                                          })
100}
101
102func getFileSize(atURL url: URL) -> Int?
103{
104        let urlResourceValue = try? url.resourceValues(forKeys: [.fileSizeKey])
105        
106        return urlResourceValue?.fileSize
107}
108/// Function fired by the local checkProgressTimer object used to track the progress of the file transfer
109/// Function fired by the local checkProgressTimer object used to track the progress of the file transfer
110@objc
111func updateProgressStatus()
112{
113        // Update the time elapsed. As mentioned earlier, a more reliable approach
114        // might be to compare the time of a Date object from when the
115        // transfer started to the time of a current Date object
116        transferTimeElapsed += 0.1
117        
118        // Verify the progress variable is valid
119        if let progress = fileTransferProgress
120        {
121            // Convert the progress into a percentage
122            let percentCompleted = 100 * progress.fractionCompleted
123            
124            // Calculate the data exchanged sent in MegaBytes
125            let dataExchangedInMB = (Double(bytesExpectedToExchange)
126                                     * progress.fractionCompleted) / 1000000
127            
128            // We have exchanged 'dataExchangedInMB' MB of data in 'transferTimeElapsed'
129            // seconds. So we have to calculate how much data will be exchanged in 1 second
130            // using cross multiplication
131            // For example:
132            // 2 MB in 0.5s
133            //  ?   in  1s
134            // MB/s = (1 x 2) / 0.5 = 4 MB/s
135            let megabytesPerSecond = (1 * dataExchangedInMB) / transferTimeElapsed
136            
137            // Convert dataExchangedInMB into a string rounded to 2 decimal places
138            let dataExchangedInMBString = String(format: "%.2f", dataExchangedInMB)
139            
140            // Convert megabytesPerSecond into a string rounded to 2 decimal places
141            let megabytesPerSecondString = String(format: "%.2f", megabytesPerSecond)
142            
143            // Update the progress an data exchanged on the UI
144            numberLabel.text = "\(percentCompleted.rounded())% - \(dataExchangedInMBString) MB @ \(megabytesPerSecondString) MB/s"
145            
146            // This is mostly useful on the browser side to check if the file transfer
147            // is complete so that we can safely deinit the timer, reset vars and update the UI
148            if percentCompleted >= 100
149            {
150                numberLabel.text = "Transfer complete!"
151                checkProgressTimer?.invalidate()
152                checkProgressTimer = nil
153                transferTimeElapsed = 0.0
154            }
155        }
156}
157

1func send(_ data: Data, toPeers peerIDs: [MCPeerID], with mode: MCSessionSendDataMode)
2func session(_ session: MCSession, 
3             didFinishReceivingResourceWithName resourceName: String, 
4             fromPeer peerID: MCPeerID, 
5             at localURL: URL?, 
6             withError error: Error?)
7func startStream(withName streamName: String, 
8                 toPeer peerID: MCPeerID) throws -> OutputStream
9// Progress variable that needs to store the progress of the file transfer
10var fileTransferProgress: Progress?
11    
12// Timer that will be used to check the file transfer progress
13var checkProgressTimer: Timer?
14
15// Used by the host to track bytes to receive
16var bytesExpectedToExchange = 0
17    
18// Used to track the time taken in transfer, this is for testing purposes.
19// You might get more reliable results using Date to track time
20var transferTimeElapsed = 0.0
21// A new action added to send the image stored in the bundle
22@IBAction func sendImageAsResource(_ sender: Any) 
23{        
24        // Call local function created
25        sendImageAsResource()
26}
27
28func sendImageAsResource()
29{
30        // 1. Get the url of the image in the project bundle.
31        // Change this if your image is hosted in your documents directory
32        // or elsewhere.
33        //
34        // 2. Get all the connected peers. For testing purposes I am only
35        // getting the first peer, you might need to loop through all your
36        // connected peers and send the files individually.
37        guard let imageURL = Bundle.main.url(forResource: "image2",
38                                             withExtension: "jpg"),
39              let guestPeerID = mcSession.connectedPeers.first else {
40            return
41        }
42        
43        // Retrieve the file size of the image
44        if let fileSizeToTransfer = getFileSize(atURL: imageURL)
45        {
46            bytesExpectedToExchange = fileSizeToTransfer
47            
48            // Put the file size in a dictionary
49            let fileTransferMeta = ["fileSize": bytesExpectedToExchange]
50            
51            // Convert the dictionary to a data object in order to send it via
52            // MultiPeer
53            let encoder = JSONEncoder()
54            
55            if let JSONData = try? encoder.encode(fileTransferMeta)
56            {
57                // Send the file size to the guest users
58                try? mcSession.send(JSONData, toPeers: mcSession.connectedPeers,
59                                    with: .reliable)
60            }
61        }
62        
63        // Ideally for best reliability, you will want to develop some logic
64        // for the guest to respond that it has received the file size and then
65        // you should initiate the transfer to that peer only after you receive
66        // this confirmation. For now, I just add a delay so that I am highly
67        // certain the guest has received this data for testing purposes
68        DispatchQueue.main.asyncAfter(deadline: .now() + 1)
69        { [weak self] in
70            self?.initiateFileTransfer(ofImage: imageURL, to: guestPeerID)
71        }
72    }
73    
74func initiateFileTransfer(ofImage imageURL: URL, to guestPeerID: MCPeerID)
75{
76        // Initialize and fire a timer to check the status of the file
77        // transfer every 0.1 second
78        checkProgressTimer = Timer.scheduledTimer(timeInterval: 0.1,
79                                                  target: self,
80                                                  selector: #selector(updateProgressStatus),
81                                                  userInfo: nil,
82                                                  repeats: true)
83        
84        // Call the sendResource function and send the image from the bundle
85        // keeping hold of the returned progress object which we need to keep checking
86        // using the timer
87        fileTransferProgress = mcSession.sendResource(at: imageURL,
88                                          withName: "image2.jpg",
89                                          toPeer: guestPeerID,
90                                          withCompletionHandler: { (error) in
91                                            
92                                            // Handle errors
93                                            if let error = error as NSError?
94                                            {
95                                                print("Error: \(error.userInfo)")
96                                                print("Error: \(error.localizedDescription)")
97                                            }
98                                            
99                                          })
100}
101
102func getFileSize(atURL url: URL) -> Int?
103{
104        let urlResourceValue = try? url.resourceValues(forKeys: [.fileSizeKey])
105        
106        return urlResourceValue?.fileSize
107}
108/// Function fired by the local checkProgressTimer object used to track the progress of the file transfer
109/// Function fired by the local checkProgressTimer object used to track the progress of the file transfer
110@objc
111func updateProgressStatus()
112{
113        // Update the time elapsed. As mentioned earlier, a more reliable approach
114        // might be to compare the time of a Date object from when the
115        // transfer started to the time of a current Date object
116        transferTimeElapsed += 0.1
117        
118        // Verify the progress variable is valid
119        if let progress = fileTransferProgress
120        {
121            // Convert the progress into a percentage
122            let percentCompleted = 100 * progress.fractionCompleted
123            
124            // Calculate the data exchanged sent in MegaBytes
125            let dataExchangedInMB = (Double(bytesExpectedToExchange)
126                                     * progress.fractionCompleted) / 1000000
127            
128            // We have exchanged 'dataExchangedInMB' MB of data in 'transferTimeElapsed'
129            // seconds. So we have to calculate how much data will be exchanged in 1 second
130            // using cross multiplication
131            // For example:
132            // 2 MB in 0.5s
133            //  ?   in  1s
134            // MB/s = (1 x 2) / 0.5 = 4 MB/s
135            let megabytesPerSecond = (1 * dataExchangedInMB) / transferTimeElapsed
136            
137            // Convert dataExchangedInMB into a string rounded to 2 decimal places
138            let dataExchangedInMBString = String(format: "%.2f", dataExchangedInMB)
139            
140            // Convert megabytesPerSecond into a string rounded to 2 decimal places
141            let megabytesPerSecondString = String(format: "%.2f", megabytesPerSecond)
142            
143            // Update the progress an data exchanged on the UI
144            numberLabel.text = "\(percentCompleted.rounded())% - \(dataExchangedInMBString) MB @ \(megabytesPerSecondString) MB/s"
145            
146            // This is mostly useful on the browser side to check if the file transfer
147            // is complete so that we can safely deinit the timer, reset vars and update the UI
148            if percentCompleted >= 100
149            {
150                numberLabel.text = "Transfer complete!"
151                checkProgressTimer?.invalidate()
152                checkProgressTimer = nil
153                transferTimeElapsed = 0.0
154            }
155        }
156}
157func session(_ session: MCSession, didReceive data: Data, fromPeer peerID: MCPeerID)
158{
159        // Check if the guest has received file transfer data
160        if let fileTransferMeta = try? JSONSerialization.jsonObject(with: data, options: []) as? [String: Int],
161           let fileSizeToReceive = fileTransferMeta["fileSize"]
162        {
163            // Store the bytes to be received in a variable
164            bytesExpectedToExchange = fileSizeToReceive
165            print("Bytes expected to receive: \(fileSizeToReceive)")
166            return
167        }
168}
169
170func session(_ session: MCSession,
171             didStartReceivingResourceWithName resourceName: String,
172             fromPeer peerID: MCPeerID,
173             with progress: Progress) 
174{
175        
176        // Store the progress object so that we can query it using the timer
177        fileTransferProgress = progress
178        
179        // Launch the main thread
180        DispatchQueue.main.async { [unowned self] in
181            
182            // Fire the timer to check the file transfer progress every 0.1 second
183            self.checkProgressTimer = Timer.scheduledTimer(timeInterval: 0.1,
184                                                           target: self,
185                                                           selector: #selector(updateProgressStatus),
186                                                           userInfo: nil,
187                                                           repeats: true)
188        }
189}
190
191func session(_ session: MCSession,
192             didFinishReceivingResourceWithName resourceName: String,
193             fromPeer peerID: MCPeerID,
194             at localURL: URL?,
195             withError error: Error?) 
196{
197        
198        // Verify that we have a valid url. You should get a url to the file in
199        // the tmp directory
200        if let url = localURL
201        {
202            // Launch the main thread
203            DispatchQueue.main.async { [weak self] in
204                
205                // Call a function to handle download completion
206                self?.handleDownloadCompletion(withImageURL: url)
207            }
208        }
209}
210
211/// Handles the file transfer completion process on the advertiser/client side
212    /// - Parameter url: URL of a file in the documents directory
213    func handleDownloadCompletion(withImageURL url: URL) 
214{ 
215        // Debugging data
216        print("Full URL: \(url.absoluteString)")
217        
218        // Invalidate the timer
219        checkProgressTimer?.invalidate()
220        checkProgressTimer = nil
221        
222        // Set the UIImageView with the downloaded image
223        imageView.image = UIImage(contentsOfFile: url.path)
224}
225

1def functionA(b, c):
2    def _innerFunction(b, c):
3        return b + c
4    return _innerFunction(b, c)
5
6def _outerFunction(b, c):
7    return b + c
8
9def functionB(b, c):
10    return _outerFunction(b, c)
11>>> functionA.__code__.co_consts
12(None, <code object _innerFunction at 0x00000296F0B6A600, file "<stdin>", line 2>, 'functionA.<locals>._innerFunction')
13

1def functionA(b, c):
2    def _innerFunction(b, c):
3        return b + c
4    return _innerFunction(b, c)
5
6def _outerFunction(b, c):
7    return b + c
8
9def functionB(b, c):
10    return _outerFunction(b, c)
11>>> functionA.__code__.co_consts
12(None, <code object _innerFunction at 0x00000296F0B6A600, file "<stdin>", line 2>, 'functionA.<locals>._innerFunction')
13>>> functionA.__code__.co_consts[1].co_code
14b'|\x00|\x01\x17\x00S\x00'
15

1def functionA(b, c):
2    def _innerFunction(b, c):
3        return b + c
4    return _innerFunction(b, c)
5
6def _outerFunction(b, c):
7    return b + c
8
9def functionB(b, c):
10    return _outerFunction(b, c)
11>>> functionA.__code__.co_consts
12(None, <code object _innerFunction at 0x00000296F0B6A600, file "<stdin>", line 2>, 'functionA.<locals>._innerFunction')
13>>> functionA.__code__.co_consts[1].co_code
14b'|\x00|\x01\x17\x00S\x00'
15>>> _outerFunction.__code__.co_code
16b'|\x00|\x01\x17\x00S\x00'
17

1def functionA(b, c):
2    def _innerFunction(b, c):
3        return b + c
4    return _innerFunction(b, c)
5
6def _outerFunction(b, c):
7    return b + c
8
9def functionB(b, c):
10    return _outerFunction(b, c)
11>>> functionA.__code__.co_consts
12(None, <code object _innerFunction at 0x00000296F0B6A600, file "<stdin>", line 2>, 'functionA.<locals>._innerFunction')
13>>> functionA.__code__.co_consts[1].co_code
14b'|\x00|\x01\x17\x00S\x00'
15>>> _outerFunction.__code__.co_code
16b'|\x00|\x01\x17\x00S\x00'
17>>> functionA.__code__.co_names
18()
19>>> functionB.__code__.co_names
20('_outerFunction',)
21

1def functionA(b, c):
2    def _innerFunction(b, c):
3        return b + c
4    return _innerFunction(b, c)
5
6def _outerFunction(b, c):
7    return b + c
8
9def functionB(b, c):
10    return _outerFunction(b, c)
11>>> functionA.__code__.co_consts
12(None, <code object _innerFunction at 0x00000296F0B6A600, file "<stdin>", line 2>, 'functionA.<locals>._innerFunction')
13>>> functionA.__code__.co_consts[1].co_code
14b'|\x00|\x01\x17\x00S\x00'
15>>> _outerFunction.__code__.co_code
16b'|\x00|\x01\x17\x00S\x00'
17>>> functionA.__code__.co_names
18()
19>>> functionB.__code__.co_names
20('_outerFunction',)
21>>> functionA.__code__.co_code
22b'd\x01d\x02\x84\x00}\x02|\x02|\x00|\x01\x83\x02S\x00'
23>>> functionB.__code__.co_code
24b't\x00|\x00|\x01\x83\x02S\x00'
25

1def functionA(b, c):
2    def _innerFunction(b, c):
3        return b + c
4    return _innerFunction(b, c)
5
6def _outerFunction(b, c):
7    return b + c
8
9def functionB(b, c):
10    return _outerFunction(b, c)
11>>> functionA.__code__.co_consts
12(None, <code object _innerFunction at 0x00000296F0B6A600, file "<stdin>", line 2>, 'functionA.<locals>._innerFunction')
13>>> functionA.__code__.co_consts[1].co_code
14b'|\x00|\x01\x17\x00S\x00'
15>>> _outerFunction.__code__.co_code
16b'|\x00|\x01\x17\x00S\x00'
17>>> functionA.__code__.co_names
18()
19>>> functionB.__code__.co_names
20('_outerFunction',)
21>>> functionA.__code__.co_code
22b'd\x01d\x02\x84\x00}\x02|\x02|\x00|\x01\x83\x02S\x00'
23>>> functionB.__code__.co_code
24b't\x00|\x00|\x01\x83\x02S\x00'
25def functionA(b, c):
26    def _innerFunction():
27        return b + c
28    for i in range(10_000_000):
29        _innerFunction() # Faster
30
31def _outerFunction(b, c):
32    return b + c
33
34def functionB(b, c):
35    for i in range(10_000_000):
36        _outerFunction(b, c) # Slower
37
38def functionC(b, c):
39    outerFunction = _outerFunction
40    for i in range(10_000_000):
41        outerFunction(b, c) # Almost same as A but still slower.
42
43py -m timeit -s "import temp;" "temp.functionA(1,2)"
441 loop, best of 5: 2.45 sec per loop
45
46py -m timeit -s "import temp;" "temp.functionB(1,2)" 
471 loop, best of 5: 3.21 sec per loop
48
49py -m timeit -s "import temp;" "temp.functionC(1,2)" 
501 loop, best of 5: 2.66 sec per loop
51

1def functionA(b, c):
2    def _innerFunction(b, c):
3        return b + c
4    return _innerFunction(b, c)
5
6def _outerFunction(b, c):
7    return b + c
8
9def functionB(b, c):
10    return _outerFunction(b, c)
11>>> functionA.__code__.co_consts
12(None, <code object _innerFunction at 0x00000296F0B6A600, file "<stdin>", line 2>, 'functionA.<locals>._innerFunction')
13>>> functionA.__code__.co_consts[1].co_code
14b'|\x00|\x01\x17\x00S\x00'
15>>> _outerFunction.__code__.co_code
16b'|\x00|\x01\x17\x00S\x00'
17>>> functionA.__code__.co_names
18()
19>>> functionB.__code__.co_names
20('_outerFunction',)
21>>> functionA.__code__.co_code
22b'd\x01d\x02\x84\x00}\x02|\x02|\x00|\x01\x83\x02S\x00'
23>>> functionB.__code__.co_code
24b't\x00|\x00|\x01\x83\x02S\x00'
25def functionA(b, c):
26    def _innerFunction():
27        return b + c
28    for i in range(10_000_000):
29        _innerFunction() # Faster
30
31def _outerFunction(b, c):
32    return b + c
33
34def functionB(b, c):
35    for i in range(10_000_000):
36        _outerFunction(b, c) # Slower
37
38def functionC(b, c):
39    outerFunction = _outerFunction
40    for i in range(10_000_000):
41        outerFunction(b, c) # Almost same as A but still slower.
42
43py -m timeit -s "import temp;" "temp.functionA(1,2)"
441 loop, best of 5: 2.45 sec per loop
45
46py -m timeit -s "import temp;" "temp.functionB(1,2)" 
471 loop, best of 5: 3.21 sec per loop
48
49py -m timeit -s "import temp;" "temp.functionC(1,2)" 
501 loop, best of 5: 2.66 sec per loop
51def functionA(b, c):  # Significantly slower
52    def _innerFunction():
53        return b + c
54    return _innerFunction()
55
56def _outerFunction(b, c):
57    return b + c
58
59def functionB(b, c):  # Significantly faster
60    return _outerFunction(b, c)
61
62
63py -m timeit -s "import temp;" "for i in range(10_000_000): temp.functionA(1,2)" 
641 loop, best of 5: 9.46 sec per loop
65
66py -m timeit -s "import temp;" "for i in range(10_000_000): temp.functionB(1,2)" 
671 loop, best of 5: 5.48 sec per loop
68